content-security-toolkit 1.0.1 → 1.0.2

package/dist/utils/logging/LoggingService.js

@@ -0,0 +1,385 @@
+import { LogLevel, getLogLevelName } from "./LogLevel";
+/**
+ * Advanced logging service with context tracking, filtering, and performance measurement
+ */
+export class LoggingService {
+    /**
+     * Create a new LoggingService
+     * @param options Configuration options
+     */
+    constructor(options) {
+        // Context tracking
+        this.contextStack = [];
+        this.contextDepth = 0;
+        // Component filtering
+        this.enabledComponents = null;
+        // Level focusing
+        this.focusedLevel = null;
+        // Console group tracking
+        this.groupDepth = 0;
+        this.componentName = options.componentName;
+        this.currentLevel = options.level ?? LogLevel.INFO;
+        this.enabled = options.enabled ?? true;
+        this.useColors = options.useColors ?? true;
+        this.includeTimestamps = options.includeTimestamps ?? true;
+        this.includeComponentName = options.includeComponentName ?? true;
+    }
+    /**
+     * Set the current log level threshold
+     * @param level New log level
+     */
+    setLevel(level) {
+        this.currentLevel = level;
+    }
+    /**
+     * Get the current log level
+     * @returns The current log level
+     */
+    getLevel() {
+        return this.currentLevel;
+    }
+    /**
+     * Get the current log level name
+     * @returns The current log level name
+     */
+    getLevelName() {
+        return getLogLevelName(this.currentLevel);
+    }
+    /**
+     * Enable or disable logging
+     * @param enabled Whether logging should be enabled
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Check if logging is enabled
+     * @returns Whether logging is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Set components to show logs for
+     * @param components Array of component names to enable, or null to enable all
+     */
+    setEnabledComponents(components) {
+        if (components === null) {
+            this.enabledComponents = null;
+        }
+        else {
+            this.enabledComponents = new Set(components);
+        }
+    }
+    /**
+     * Focus on a specific log level
+     * @param level Level to focus on, or null to show all levels
+     */
+    focusLevel(level) {
+        this.focusedLevel = level;
+    }
+    /**
+     * 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 = "context") {
+        this.contextDepth++;
+        const context = {
+            name: contextName,
+            startTime: performance.now(),
+            depth: this.contextDepth,
+        };
+        this.contextStack.push(context);
+        this.trace(`Entering ${contextName}`);
+        // Return a function that exits this context
+        return () => {
+            this.exitContext();
+        };
+    }
+    /**
+     * Decrease context depth (call when exiting a loop or nested function)
+     */
+    exitContext() {
+        if (this.contextStack.length > 0) {
+            const context = this.contextStack.pop();
+            this.contextDepth = Math.max(0, this.contextDepth - 1);
+            const duration = performance.now() - context.startTime;
+            this.trace(`Exiting ${context.name} (took ${duration.toFixed(2)}ms)`);
+        }
+    }
+    /**
+     * 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(contextName, fn) {
+        const exitFn = this.enterContext(contextName);
+        try {
+            return fn();
+        }
+        finally {
+            exitFn();
+        }
+    }
+    /**
+     * 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
+     */
+    async withContextAsync(contextName, fn) {
+        const exitFn = this.enterContext(contextName);
+        try {
+            return await fn();
+        }
+        finally {
+            exitFn();
+        }
+    }
+    /**
+     * Start a console group
+     * @param label Label for the group
+     * @param collapsed Whether the group should be collapsed
+     */
+    startGroup(label, collapsed = false) {
+        if (!this.shouldLog(LogLevel.INFO))
+            return;
+        this.groupDepth++;
+        if (collapsed) {
+            console.groupCollapsed(this.formatMessage(LogLevel.INFO, label));
+        }
+        else {
+            console.group(this.formatMessage(LogLevel.INFO, label));
+        }
+    }
+    /**
+     * End the current console group
+     */
+    endGroup() {
+        if (this.groupDepth > 0) {
+            console.groupEnd();
+            this.groupDepth--;
+        }
+    }
+    /**
+     * 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(label, fn, collapsed = false) {
+        this.startGroup(label, collapsed);
+        try {
+            return fn();
+        }
+        finally {
+            this.endGroup();
+        }
+    }
+    /**
+     * 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
+     */
+    async groupAsync(label, fn, collapsed = false) {
+        this.startGroup(label, collapsed);
+        try {
+            return await fn();
+        }
+        finally {
+            this.endGroup();
+        }
+    }
+    /**
+     * 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(label, fn) {
+        const start = performance.now();
+        const result = fn();
+        const duration = performance.now() - start;
+        this.info(`${label} took ${duration.toFixed(2)}ms`);
+        return { result, duration };
+    }
+    /**
+     * 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
+     */
+    async timeAsync(label, fn) {
+        const start = performance.now();
+        const result = await fn();
+        const duration = performance.now() - start;
+        this.info(`${label} took ${duration.toFixed(2)}ms`);
+        return { result, duration };
+    }
+    /**
+     * Log with automatic level adjustment based on context depth
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    logWithContext(message, ...args) {
+        // Adjust level based on nesting - deeper nesting means more detailed level
+        const adjustedLevel = Math.min(LogLevel.VERBOSE, LogLevel.INFO + this.contextDepth);
+        this.log(adjustedLevel, message, ...args);
+    }
+    /**
+     * Main logging method
+     * @param level Log level
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(level, message, ...args) {
+        if (!this.shouldLog(level))
+            return;
+        const formattedMessage = this.formatMessage(level, message);
+        switch (level) {
+            case LogLevel.ERROR:
+                console.error(formattedMessage, ...args);
+                break;
+            case LogLevel.WARN:
+                console.warn(formattedMessage, ...args);
+                break;
+            default:
+                console.log(formattedMessage, ...args);
+                break;
+        }
+    }
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message, ...args) {
+        this.log(LogLevel.ERROR, message, ...args);
+    }
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message, ...args) {
+        this.log(LogLevel.WARN, message, ...args);
+    }
+    /**
+     * Log an info message
+     * @param message Info message
+     * @param args Additional arguments to log
+     */
+    info(message, ...args) {
+        this.log(LogLevel.INFO, message, ...args);
+    }
+    /**
+     * Log a debug message
+     * @param message Debug message
+     * @param args Additional arguments to log
+     */
+    debug(message, ...args) {
+        this.log(LogLevel.DEBUG, message, ...args);
+    }
+    /**
+     * Log a trace message
+     * @param message Trace message
+     * @param args Additional arguments to log
+     */
+    trace(message, ...args) {
+        this.log(LogLevel.TRACE, message, ...args);
+    }
+    /**
+     * Log a verbose message
+     * @param message Verbose message
+     * @param args Additional arguments to log
+     */
+    verbose(message, ...args) {
+        this.log(LogLevel.VERBOSE, message, ...args);
+    }
+    /**
+     * Check if a message should be logged
+     * @param level Log level of the message
+     * @returns Whether the message should be logged
+     */
+    shouldLog(level) {
+        // Always log errors and warnings, otherwise respect enabled flag
+        if (!this.enabled && level > LogLevel.WARN)
+            return false;
+        // If we're focusing on a specific level, only log messages at that level
+        if (this.focusedLevel !== null) {
+            return level === this.focusedLevel || level <= LogLevel.WARN;
+        }
+        // Otherwise, respect the level threshold
+        if (level > this.currentLevel && level > LogLevel.WARN)
+            return false;
+        // Check if component is enabled
+        if (this.enabledComponents !== null && !this.enabledComponents.has(this.componentName)) {
+            // Still allow errors and warnings
+            return level <= LogLevel.WARN;
+        }
+        return true;
+    }
+    /**
+     * Format a log message
+     * @param level Log level
+     * @param message Message to format
+     * @returns Formatted message
+     */
+    formatMessage(level, message) {
+        const parts = [];
+        // Add timestamp if enabled
+        if (this.includeTimestamps) {
+            parts.push(this.getTimestamp());
+        }
+        // Add level prefix
+        parts.push(this.getLevelPrefix(level));
+        // Add component name if enabled
+        if (this.includeComponentName) {
+            parts.push(this.componentName);
+        }
+        // Add indentation based on context depth
+        const indentation = "  ".repeat(this.contextDepth);
+        // Combine all parts
+        return `${parts.join(" ")}: ${indentation}${message}`;
+    }
+    /**
+     * Get the current timestamp as a string
+     * @returns Formatted timestamp
+     */
+    getTimestamp() {
+        const now = new Date();
+        return `[${now.toISOString()}]`;
+    }
+    /**
+     * Get prefix for log level
+     * @param level Log level
+     * @returns Formatted prefix
+     */
+    getLevelPrefix(level) {
+        if (!this.useColors) {
+            return `[${getLogLevelName(level)}]`;
+        }
+        // Use colors for different levels
+        switch (level) {
+            case LogLevel.ERROR:
+                return "\x1b[31m[ERROR]\x1b[0m"; // Red
+            case LogLevel.WARN:
+                return "\x1b[33m[WARN]\x1b[0m"; // Yellow
+            case LogLevel.INFO:
+                return "\x1b[36m[INFO]\x1b[0m"; // Cyan
+            case LogLevel.DEBUG:
+                return "\x1b[32m[DEBUG]\x1b[0m"; // Green
+            case LogLevel.TRACE:
+                return "\x1b[35m[TRACE]\x1b[0m"; // Magenta
+            case LogLevel.VERBOSE:
+                return "\x1b[90m[VERBOSE]\x1b[0m"; // Gray
+            default:
+                return `[${getLogLevelName(level)}]`;
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+export declare class SimpleLoggingService {
+    private componentName;
+    private debugMode;
+    /**
+     * Create a new SimpleLoggingService
+     * for consistent logging across the toolkit
+     * @param componentName Name of the component for log prefixing
+     * @param debugMode Whether debug mode is enabled
+     */
+    constructor(componentName: string, debugMode?: boolean);
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(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 error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled: boolean): void;
+    /**
+     * Get current debug mode
+     * @returns Whether debug mode is enabled
+     */
+    isDebugEnabled(): boolean;
+}

package/dist/utils/logging/SimpleLoggingService.js

@@ -0,0 +1,58 @@
+export class SimpleLoggingService {
+    /**
+     * Create a new SimpleLoggingService
+     * for consistent logging across the toolkit
+     * @param componentName Name of the component for log prefixing
+     * @param debugMode Whether debug mode is enabled
+     */
+    constructor(componentName, debugMode = false) {
+        this.componentName = componentName;
+        this.debugMode = debugMode;
+    }
+    /**
+     * Log a debug message if debug mode is enabled
+     * @param message Message to log
+     * @param args Additional arguments to log
+     */
+    log(message, ...args) {
+        if (this.debugMode) {
+            console.log(`${this.componentName}: ${message}`, ...args);
+        }
+    }
+    /**
+     * Log a warning message
+     * @param message Warning message
+     * @param args Additional arguments to log
+     */
+    warn(message, ...args) {
+        if (this.debugMode) {
+            console.warn(`${this.componentName}: ${message}`, ...args);
+        }
+        else {
+            // In non-debug mode, only log the message without args for brevity
+            console.warn(`${this.componentName}: ${message}`);
+        }
+    }
+    /**
+     * Log an error message
+     * @param message Error message
+     * @param args Additional arguments to log
+     */
+    error(message, ...args) {
+        console.error(`${this.componentName}: ${message}`, ...args);
+    }
+    /**
+     * Set debug mode
+     * @param enabled Whether debug mode should be enabled
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+    }
+    /**
+     * Get current debug mode
+     * @returns Whether debug mode is enabled
+     */
+    isDebugEnabled() {
+        return this.debugMode;
+    }
+}

package/dist/utils/logging/advanced/LogLevel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Enum defining log severity levels
+ */
+export declare enum LogLevel {
+    ERROR = 0,// Always shown, represents errors that need immediate attention
+    WARN = 1,// Important issues that don't break functionality but need attention
+    INFO = 2,// General information about application flow
+    DEBUG = 3,// Detailed information useful for debugging
+    TRACE = 4,// Very detailed information, including loop iterations, function entries/exits
+    VERBOSE = 5
+}
+/**
+ * Map of log level names to their enum values
+ */
+export declare const LOG_LEVEL_MAP: Record<string, LogLevel>;
+/**
+ * Get the name of a log level
+ * @param level The log level
+ * @returns The name of the log level
+ */
+export declare function getLogLevelName(level: LogLevel): string;

package/dist/utils/logging/advanced/LogLevel.js

@@ -0,0 +1,46 @@
+/**
+ * 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/advanced/LoggingConfig.d.ts

@@ -0,0 +1,68 @@
+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/advanced/LoggingConfig.js

@@ -0,0 +1,64 @@
+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/advanced/LoggingFactory.d.ts

@@ -0,0 +1,22 @@
+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>;
+}