content-security-toolkit 1.0.1 → 1.0.2

package/dist/utils/logging/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/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/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/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>;
+}

package/dist/utils/logging/LoggingFactory.js

@@ -0,0 +1,61 @@
+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

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