@decaf-ts/logging 0.2.3 → 0.3.0

package/dist/logging.cjs

@@ -8,7 +8,7 @@
      * @description Enum for log levels.
      * @summary Defines different levels of logging for the application.
      * @enum {string}
-     * @memberOf @decaf-ts/utils
+     * @memberOf module:Logging
      */
     exports.LogLevel = void 0;
     (function (LogLevel) {
@@ -26,13 +26,13 @@
     /**
      * @description Numeric values associated with log levels.
      * @summary Provides a numeric representation of log levels for comparison and filtering.
-     * @const {Object} NumericLogLevels
-     * @property {number} error - Numeric value for error level (0).
-     * @property {number} info - Numeric value for info level (2).
-     * @property {number} verbose - Numeric value for verbose level (4).
-     * @property {number} debug - Numeric value for debug level (5).
-     * @property {number} silly - Numeric value for silly level (8).
-     * @memberOf @decaf-ts/utils
+     * @const NumericLogLevels
+     * @property {number} error - Numeric value for error level (2).
+     * @property {number} info - Numeric value for info level (4).
+     * @property {number} verbose - Numeric value for verbose level (6).
+     * @property {number} debug - Numeric value for debug level (7).
+     * @property {number} silly - Numeric value for silly level (9).
+     * @memberOf module:Logging
      */
     const NumericLogLevels = {
         error: 2,
@@ -41,9 +41,17 @@
         debug: 7,
         silly: 9,
     };
+    /**
+     * @description Enum for logging output modes.
+     * @summary Defines different output formats for log messages.
+     * @enum {string}
+     * @memberOf module:Logging
+     */
     exports.LoggingMode = void 0;
     (function (LoggingMode) {
+        /** Raw text format for human readability */
         LoggingMode["RAW"] = "raw";
+        /** JSON format for machine parsing */
         LoggingMode["JSON"] = "json";
     })(exports.LoggingMode || (exports.LoggingMode = {}));
     /**
@@ -52,23 +60,24 @@
      * @const DefaultTheme
      * @typedef {Theme} DefaultTheme
      * @property {Object} class - Styling for class names.
-     * @property {number} class.fg - Foreground color code for class names (4).
+     * @property {number} class.fg - Foreground color code for class names (34).
      * @property {Object} id - Styling for identifiers.
      * @property {number} id.fg - Foreground color code for identifiers (36).
      * @property {Object} stack - Styling for stack traces (empty object).
      * @property {Object} timestamp - Styling for timestamps (empty object).
      * @property {Object} message - Styling for different types of messages.
      * @property {Object} message.error - Styling for error messages.
-     * @property {number} message.error.fg - Foreground color code for error messages (34).
+     * @property {number} message.error.fg - Foreground color code for error messages (31).
      * @property {Object} method - Styling for method names (empty object).
      * @property {Object} logLevel - Styling for different log levels.
      * @property {Object} logLevel.error - Styling for error level logs.
-     * @property {number} logLevel.error.fg - Foreground color code for error level logs (6).
+     * @property {number} logLevel.error.fg - Foreground color code for error level logs (31).
+     * @property {string[]} logLevel.error.style - Style attributes for error level logs (["bold"]).
      * @property {Object} logLevel.info - Styling for info level logs (empty object).
      * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).
      * @property {Object} logLevel.debug - Styling for debug level logs.
-     * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (7).
-     * @memberOf @decaf-ts/utils
+     * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).
+     * @memberOf module:Logging
      */
     const DefaultTheme = {
         class: {
@@ -104,12 +113,15 @@
      * @typedef {LoggingConfig} DefaultLoggingConfig
      * @property {number} verbose - Verbosity level (0).
      * @property {LogLevel} level - Default log level (LogLevel.info).
+     * @property {boolean} logLevel - Whether to display log level in output (true).
+     * @property {LoggingMode} mode - Output format mode (LoggingMode.RAW).
      * @property {boolean} style - Whether to apply styling to log output (false).
+     * @property {string} separator - Separator between log components (" - ").
      * @property {boolean} timestamp - Whether to include timestamps in log messages (true).
      * @property {string} timestampFormat - Format for timestamps ("HH:mm:ss.SSS").
      * @property {boolean} context - Whether to include context information in log messages (true).
      * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).
-     * @memberOf @decaf-ts/utils
+     * @memberOf module:Logging
      */
     const DefaultLoggingConfig = {
         verbose: 0,
@@ -117,6 +129,7 @@
         logLevel: true,
         mode: exports.LoggingMode.RAW,
         style: false,
+        contextSeparator: ".",
         separator: " - ",
         timestamp: true,
         timestampFormat: "HH:mm:ss.SSS",
@@ -126,20 +139,29 @@
 
     /**
      * @description A minimal logger implementation.
-     * @summary MiniLogger is a lightweight logging class that implements the VerbosityLogger interface.
-     * It provides basic logging functionality with support for different log levels and verbosity.
+     * @summary MiniLogger is a lightweight logging class that implements the Logger interface.
+     * It provides basic logging functionality with support for different log levels, verbosity,
+     * context-aware logging, and customizable formatting.
+     * @param {string} context - The context (typically class name) this logger is associated with
+     * @param {Partial<LoggingConfig>} conf - Optional configuration to override global settings
+     * @class MiniLogger
+     * @example
+     * // Create a new logger for a class
+     * const logger = new MiniLogger('MyClass');
+     *
+     * // Log messages at different levels
+     * logger.info('This is an info message');
+     * logger.debug('This is a debug message');
+     * logger.error('Something went wrong');
      *
-     * @class
+     * // Create a child logger for a specific method
+     * const methodLogger = logger.for('myMethod');
+     * methodLogger.verbose('Detailed information', 2);
+     *
+     * // Log with custom configuration
+     * logger.for('specialMethod', { style: true }).info('Styled message');
      */
     class MiniLogger {
-        /**
-         * @description Creates a new MiniLogger instance.
-         * @summary Initializes a MiniLogger with the given class name, optional configuration, and method name.
-         *
-         * @param context - The name of the class using this logger.
-         * @param [conf] - Optional logging configuration. Defaults to Info level and verbosity 0.
-         * @param [id] - Optional unique identifier for the logger instance.
-         */
         constructor(context, conf) {
             this.context = context;
             this.conf = conf;
@@ -149,22 +171,46 @@
                 return this.conf[key];
             return Logging.getConfig()[key];
         }
-        for(method, config, ...args) {
+        /**
+         * @description Creates a child logger for a specific method or context
+         * @summary Returns a new logger instance with the current context extended by the specified method name
+         * @param {string | Function} method - The method name or function to create a logger for
+         * @param {Partial<LoggingConfig>} config - Optional configuration to override settings
+         * @param {...any} args - Additional arguments to pass to the logger factory
+         * @return {Logger} A new logger instance for the specified method
+         */
+        for(method, config) {
             method = method
                 ? typeof method === "string"
                     ? method
                     : method.name
                 : undefined;
-            return Logging.for([this.context, method].join("."), config, ...args);
+            return new Proxy(this, {
+                get: (target, p, receiver) => {
+                    const result = Reflect.get(target, p, receiver);
+                    if (p === "config") {
+                        return new Proxy(this.config, {
+                            get: (target, p) => {
+                                if (config && p in config)
+                                    return config[p];
+                                return Reflect.get(target, p, receiver);
+                            },
+                        });
+                    }
+                    if (p === "context") {
+                        return [result, method].join(".");
+                    }
+                    return result;
+                },
+            });
         }
         /**
-         * @description Creates a formatted log string.
-         * @summary Generates a log string with timestamp, colored log level, and message.
-         *
-         * @param level - The log level as a string.
-         * @param message
-         * @param stack
-         * @return A formatted log string.
+         * @description Creates a formatted log string
+         * @summary Generates a log string with timestamp, colored log level, context, and message
+         * @param {LogLevel} level - The log level for this message
+         * @param {StringLike | Error} message - The message to log or an Error object
+         * @param {string} [stack] - Optional stack trace to include in the log
+         * @return {string} A formatted log string with all components
          */
         createLog(level, message, stack) {
             const log = [];
@@ -209,13 +255,13 @@
             return log.join(this.config("separator"));
         }
         /**
-         * @description Logs a message with the specified log level.
+         * @description Logs a message with the specified log level
          * @summary Checks if the message should be logged based on the current log level,
-         * then uses the appropriate console method to output the log.
-         *
-         * @param level - The log level of the message.
-         * @param msg - The message to be logged.
-         * @param stack
+         * then uses the appropriate console method to output the formatted log
+         * @param {LogLevel} level - The log level of the message
+         * @param {StringLike | Error} msg - The message to be logged or an Error object
+         * @param {string} [stack] - Optional stack trace to include in the log
+         * @return {void}
          */
         log(level, msg, stack) {
             if (NumericLogLevels[this.config("level")] <
@@ -239,96 +285,166 @@
             method(this.createLog(level, msg, stack));
         }
         /**
-         * @description LLogs a `way too verbose` or a silly message.
-         * @summary Logs a message at the Silly level if the current verbosity allows it.
-         *
-         * @param msg - The message to be logged.
-         * @param verbosity - The verbosity level of the message (default: 0).
+         * @description Logs a message at the silly level
+         * @summary Logs a message at the silly level if the current verbosity setting allows it
+         * @param {StringLike} msg - The message to be logged
+         * @param {number} [verbosity=0] - The verbosity level of the message
+         * @return {void}
          */
         silly(msg, verbosity = 0) {
             if (this.config("verbose") >= verbosity)
                 this.log(exports.LogLevel.verbose, msg);
         }
         /**
-         * @description Logs a verbose message.
-         * @summary Logs a message at the Verbose level if the current verbosity allows it.
-         *
-         * @param msg - The message to be logged.
-         * @param verbosity - The verbosity level of the message (default: 0).
+         * @description Logs a message at the verbose level
+         * @summary Logs a message at the verbose level if the current verbosity setting allows it
+         * @param {StringLike} msg - The message to be logged
+         * @param {number} [verbosity=0] - The verbosity level of the message
+         * @return {void}
          */
         verbose(msg, verbosity = 0) {
             if (this.config("verbose") >= verbosity)
                 this.log(exports.LogLevel.verbose, msg);
         }
         /**
-         * @description Logs an info message.
-         * @summary Logs a message at the Info level.
-         *
-         * @param msg - The message to be logged.
+         * @description Logs a message at the info level
+         * @summary Logs a message at the info level for general application information
+         * @param {StringLike} msg - The message to be logged
+         * @return {void}
          */
         info(msg) {
             this.log(exports.LogLevel.info, msg);
         }
         /**
-         * @description Logs a debug message.
-         * @summary Logs a message at the Debug level.
-         *
-         * @param msg - The message to be logged.
+         * @description Logs a message at the debug level
+         * @summary Logs a message at the debug level for detailed troubleshooting information
+         * @param {StringLike} msg - The message to be logged
+         * @return {void}
          */
         debug(msg) {
             this.log(exports.LogLevel.debug, msg);
         }
         /**
-         * @description Logs an error message.
-         * @summary Logs a message at the Error level.
-         *
-         * @param msg - The message to be logged.
+         * @description Logs a message at the error level
+         * @summary Logs a message at the error level for errors and exceptions
+         * @param {StringLike | Error} msg - The message to be logged or an Error object
+         * @return {void}
          */
         error(msg) {
             this.log(exports.LogLevel.error, msg);
         }
+        /**
+         * @description Updates the logger configuration
+         * @summary Merges the provided configuration with the existing configuration
+         * @param {Partial<LoggingConfig>} config - The configuration options to apply
+         * @return {void}
+         */
         setConfig(config) {
             this.conf = { ...(this.conf || {}), ...config };
         }
     }
     /**
-     * @description A static class for managing logging operations.
+     * @description A static class for managing logging operations
      * @summary The Logging class provides a centralized logging mechanism with support for
-     * different log levels and verbosity. It uses a singleton pattern to maintain a global
+     * different log levels, verbosity, and styling. It uses a singleton pattern to maintain a global
      * logger instance and allows creating specific loggers for different classes and methods.
+     * @class Logging
+     * @example
+     * // Set global configuration
+     * Logging.setConfig({ level: LogLevel.debug, style: true });
+     *
+     * // Get a logger for a specific class
+     * const logger = Logging.for('MyClass');
+     *
+     * // Log messages at different levels
+     * logger.info('Application started');
+     * logger.debug('Processing data...');
+     *
+     * // Log with context
+     * const methodLogger = Logging.for('MyClass.myMethod');
+     * methodLogger.verbose('Detailed operation information', 1);
+     *
+     * // Log errors
+     * try {
+     *   // some operation
+     * } catch (error) {
+     *   logger.error(error);
+     * }
+     * @mermaid
+     * classDiagram
+     *   class Logger {
+     *     <<interface>>
+     *     +for(method, config, ...args)
+     *     +silly(msg, verbosity)
+     *     +verbose(msg, verbosity)
+     *     +info(msg)
+     *     +debug(msg)
+     *     +error(msg)
+     *     +setConfig(config)
+     *   }
+     *
+     *   class Logging {
+     *     -global: Logger
+     *     -_factory: LoggerFactory
+     *     -_config: LoggingConfig
+     *     +setFactory(factory)
+     *     +setConfig(config)
+     *     +getConfig()
+     *     +get()
+     *     +verbose(msg, verbosity)
+     *     +info(msg)
+     *     +debug(msg)
+     *     +silly(msg)
+     *     +error(msg)
+     *     +for(object, config, ...args)
+     *     +because(reason, id)
+     *     +theme(text, type, loggerLevel, template)
+     *   }
+     *
+     *   class MiniLogger {
+     *     +constructor(context, conf?)
+     *   }
      *
-     * @class
+     *   Logging ..> Logger : creates
+     *   Logging ..> MiniLogger : creates by default
      */
     class Logging {
         /**
-         * @description Factory function for creating logger instances.
-         * @summary A function that creates new VerbosityLogger instances. By default, it creates a MiniLogger.
+         * @description Factory function for creating logger instances
+         * @summary A function that creates new Logger instances. By default, it creates a MiniLogger.
          */
         static { this._factory = (object, config) => {
             return new MiniLogger(object, config);
         }; }
         /**
-         * @description Configuration for the logging system.
-         * @summary Stores the global verbosity level and log level settings.
+         * @description Configuration for the logging system
+         * @summary Stores the global logging configuration including verbosity, log level, styling, and formatting settings
          */
         static { this._config = DefaultLoggingConfig; }
+        constructor() { }
         /**
-         * @description Private constructor to prevent instantiation.
-         * @summary Ensures that the Logging class cannot be instantiated as it's designed to be used statically.
+         * @description Sets the factory function for creating logger instances
+         * @summary Allows customizing how logger instances are created
+         * @param {LoggerFactory} factory - The factory function to use for creating loggers
+         * @return {void}
          */
-        constructor() { }
         static setFactory(factory) {
             Logging._factory = factory;
         }
         /**
-         * @description Setter for the logging configuration.
-         * @summary Allows updating the global logging configuration.
-         *
-         * @param config - An object containing verbosity and log level settings.
+         * @description Updates the global logging configuration
+         * @summary Allows updating the global logging configuration with new settings
+         * @param {Partial<LoggingConfig>} config - The configuration options to apply
+         * @return {void}
          */
         static setConfig(config) {
             Object.assign(this._config, config);
         }
+        /**
+         * @description Gets a copy of the current global logging configuration
+         * @summary Returns a copy of the current global logging configuration
+         * @return {LoggingConfig} A copy of the current configuration
+         */
         static getConfig() {
             return Object.assign({}, this._config);
         }
@@ -388,6 +504,14 @@
         static error(msg) {
             return this.get().error(msg);
         }
+        /**
+         * @description Creates a logger for a specific object or context
+         * @summary Creates a new logger instance for the given object or context using the factory function
+         * @param {LoggingContext} object - The object, class, or context to create a logger for
+         * @param {Partial<LoggingConfig>} [config] - Optional configuration to override global settings
+         * @param {...any} args - Additional arguments to pass to the logger factory
+         * @return {Logger} A new logger instance for the specified object or context
+         */
         static for(object, config, ...args) {
             object =
                 typeof object === "string"
@@ -410,6 +534,39 @@
         static because(reason, id) {
             return this._factory(reason, this._config, id);
         }
+        /**
+         * @description Applies theme styling to text
+         * @summary Applies styling (colors, formatting) to text based on the theme configuration
+         * @param {string} text - The text to style
+         * @param {string} type - The type of element to style (e.g., "class", "message", "logLevel")
+         * @param {LogLevel} loggerLevel - The log level to use for styling
+         * @param {Theme} [template=DefaultTheme] - The theme to use for styling
+         * @return {string} The styled text
+         * @mermaid
+         * sequenceDiagram
+         *   participant Caller
+         *   participant Theme as Logging.theme
+         *   participant Apply as apply function
+         *   participant Style as styled-string-builder
+         *
+         *   Caller->>Theme: theme(text, type, loggerLevel)
+         *   Theme->>Theme: Check if styling is enabled
+         *   alt styling disabled
+         *     Theme-->>Caller: return original text
+         *   else styling enabled
+         *     Theme->>Theme: Get theme for type
+         *     alt theme not found
+         *       Theme-->>Caller: return original text
+         *     else theme found
+         *       Theme->>Theme: Determine actual theme based on log level
+         *       Theme->>Apply: Apply each style property
+         *       Apply->>Style: Apply colors and formatting
+         *       Style-->>Apply: Return styled text
+         *       Apply-->>Theme: Return styled text
+         *       Theme-->>Caller: Return final styled text
+         *     end
+         *   end
+         */
         static theme(text, type, loggerLevel, template = DefaultTheme) {
             if (!this._config.style)
                 return text;
@@ -484,6 +641,37 @@
         }
     }
 
+    /**
+     * @description Method decorator for logging function calls
+     * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity
+     * @param {LogLevel} level - The log level to use (default: LogLevel.info)
+     * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
+     * @param {number} [verbosity=0] - The verbosity level for the log messages (default: 0)
+     * @return {Function} A method decorator that wraps the original method with logging
+     * @function log
+     * @category Decorators
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant Decorator as log decorator
+     *   participant Method as Original Method
+     *   participant Logger as Logging instance
+     *
+     *   Client->>Decorator: call decorated method
+     *   Decorator->>Logger: log method call
+     *   Decorator->>Method: call original method
+     *   alt result is Promise
+     *     Method-->>Decorator: return Promise
+     *     Decorator->>Decorator: attach then handler
+     *     Note over Decorator: Promise resolves
+     *     Decorator->>Logger: log benchmark (if enabled)
+     *     Decorator-->>Client: return result
+     *   else result is not Promise
+     *     Method-->>Decorator: return result
+     *     Decorator->>Logger: log benchmark (if enabled)
+     *     Decorator-->>Client: return result
+     *   end
+     */
     function log(level = exports.LogLevel.info, benchmark = false, verbosity = 0) {
         return function (target, propertyKey, descriptor) {
             const log = Logging.for(target).for(target[propertyKey]);
@@ -513,37 +701,64 @@
             };
         };
     }
+    /**
+     * @description Method decorator for logging function calls with debug level
+     * @summary Convenience wrapper around the log decorator that uses LogLevel.debug
+     * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
+     * @return {Function} A method decorator that wraps the original method with debug logging
+     * @function debug
+     * @category Decorators
+     */
     function debug(benchmark = false) {
         return log(exports.LogLevel.debug, benchmark);
     }
+    /**
+     * @description Method decorator for logging function calls with info level
+     * @summary Convenience wrapper around the log decorator that uses LogLevel.info
+     * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
+     * @return {Function} A method decorator that wraps the original method with info logging
+     * @function info
+     * @category Decorators
+     */
     function info(benchmark = false) {
         return log(exports.LogLevel.info, benchmark);
     }
+    /**
+     * @description Method decorator for logging function calls with silly level
+     * @summary Convenience wrapper around the log decorator that uses LogLevel.silly
+     * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
+     * @return {Function} A method decorator that wraps the original method with silly logging
+     * @function silly
+     * @category Decorators
+     */
     function silly(benchmark = false) {
         return log(exports.LogLevel.silly, benchmark);
     }
+    /**
+     * @description Method decorator for logging function calls with verbose level
+     * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity
+     * @param {number} verbosity - The verbosity level for the log messages (default: 0)
+     * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)
+     * @return {Function} A method decorator that wraps the original method with verbose logging
+     * @function verbose
+     * @category Decorators
+     */
     function verbose(verbosity = 0, benchmark = false) {
         return log(exports.LogLevel.verbose, benchmark, verbosity);
     }
 
     /**
-     * @summary Module summary
-     * @description Module description
+     * @description A logging module for TypeScript applications
+     * @summary This module provides a comprehensive logging solution for TypeScript applications. It exports constants, decorators, logging utilities, and type definitions to facilitate structured logging.
      * @module Logging
      */
     /**
-     * @summary Logging
-     * @description Namespace description
-     * @namespace Logging
-     * @memberOf module:Logging
-     */
-    /**
-     * @summary stores the current package version
-     * @description this is how you should document a constant
+     * @description Current package version string
+     * @summary Stores the current package version, used for version tracking and compatibility checks
      * @const VERSION
-     * @memberOf module:ts-workspace
+     * @memberOf module:Logging
      */
-    const VERSION = "0.2.2";
+    const VERSION = "0.3.0";
 
     exports.DefaultLoggingConfig = DefaultLoggingConfig;
     exports.DefaultTheme = DefaultTheme;
@@ -558,4 +773,4 @@
     exports.verbose = verbose;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.cjs","sources":["../src/constants.ts","../src/logging.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["import { LoggingConfig, Theme } from \"./types\";\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @memberOf @decaf-ts/utils\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const {Object} NumericLogLevels\n * @property {number} error - Numeric value for error level (0).\n * @property {number} info - Numeric value for info level (2).\n * @property {number} verbose - Numeric value for verbose level (4).\n * @property {number} debug - Numeric value for debug level (5).\n * @property {number} silly - Numeric value for silly level (8).\n * @memberOf @decaf-ts/utils\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\nexport enum LoggingMode {\n  RAW = \"raw\",\n  JSON = \"json\",\n}\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (4).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (34).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (6).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (7).\n * @memberOf @decaf-ts/utils\n */\nexport const DefaultTheme: Theme = {\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {},\n    verbose: {},\n    debug: {\n      fg: 33,\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf @decaf-ts/utils\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  mode: LoggingMode.RAW,\n  style: false,\n  separator: \" - \",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  theme: DefaultTheme,\n};\n","import {\n  LoggerFactory,\n  LoggingConfig,\n  LoggingContext,\n  StringLike,\n  Theme,\n  ThemeOption,\n  ThemeOptionByLogLevel,\n  Logger,\n} from \"./types\";\nimport { ColorizeOptions, style, StyledString } from \"styled-string-builder\";\nimport {\n  DefaultLoggingConfig,\n  DefaultTheme,\n  LogLevel,\n  NumericLogLevels,\n} from \"./constants\";\n\n/**\n * @description A minimal logger implementation.\n * @summary MiniLogger is a lightweight logging class that implements the VerbosityLogger interface.\n * It provides basic logging functionality with support for different log levels and verbosity.\n *\n * @class\n */\nexport class MiniLogger implements Logger {\n  /**\n   * @description Creates a new MiniLogger instance.\n   * @summary Initializes a MiniLogger with the given class name, optional configuration, and method name.\n   *\n   * @param context - The name of the class using this logger.\n   * @param [conf] - Optional logging configuration. Defaults to Info level and verbosity 0.\n   * @param [id] - Optional unique identifier for the logger instance.\n   */\n  constructor(\n    protected context: string,\n    protected conf?: Partial<LoggingConfig>\n  ) {}\n\n  protected config(\n    key: keyof LoggingConfig\n  ): LoggingConfig[keyof LoggingConfig] {\n    if (this.conf && key in this.conf) return this.conf[key];\n    return Logging.getConfig()[key];\n  }\n\n  for(\n    method?: string | ((...args: any[]) => any),\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger {\n    method = method\n      ? typeof method === \"string\"\n        ? method\n        : method.name\n      : undefined;\n\n    return Logging.for([this.context, method].join(\".\"), config, ...args);\n  }\n\n  /**\n   * @description Creates a formatted log string.\n   * @summary Generates a log string with timestamp, colored log level, and message.\n   *\n   * @param level - The log level as a string.\n   * @param message\n   * @param stack\n   * @return A formatted log string.\n   */\n  protected createLog(\n    level: LogLevel,\n    message: StringLike | Error,\n    stack?: string\n  ): string {\n    const log: string[] = [];\n    const style = this.config(\"style\");\n    if (this.config(\"timestamp\")) {\n      const date = new Date().toISOString();\n      const timestamp = style ? Logging.theme(date, \"timestamp\", level) : date;\n      log.push(timestamp);\n    }\n\n    if (this.config(\"logLevel\")) {\n      const lvl: string = style\n        ? Logging.theme(level, \"logLevel\", level)\n        : level;\n      log.push(lvl);\n    }\n\n    if (this.config(\"context\")) {\n      const context: string = style\n        ? Logging.theme(this.context, \"class\", level)\n        : this.context;\n      log.push(context);\n    }\n\n    if (this.config(\"correlationId\")) {\n      {\n        const id: string = style\n          ? Logging.theme(this.config(\"correlationId\")!.toString(), \"id\", level)\n          : this.config(\"correlationId\")!.toString();\n        log.push(id);\n      }\n    }\n\n    const msg: string = style\n      ? Logging.theme(\n          typeof message === \"string\" ? message : (message as Error).message,\n          \"message\",\n          level\n        )\n      : typeof message === \"string\"\n        ? message\n        : (message as Error).message;\n    log.push(msg);\n    if (stack || message instanceof Error) {\n      stack = style\n        ? Logging.theme(\n            (stack || (message as Error).stack) as string,\n            \"stack\",\n            level\n          )\n        : stack;\n      log.push(`\\nStack trace:\\n${stack}`);\n    }\n\n    return log.join(this.config(\"separator\") as string);\n  }\n\n  /**\n   * @description Logs a message with the specified log level.\n   * @summary Checks if the message should be logged based on the current log level,\n   * then uses the appropriate console method to output the log.\n   *\n   * @param level - The log level of the message.\n   * @param msg - The message to be logged.\n   * @param stack\n   */\n  protected log(\n    level: LogLevel,\n    msg: StringLike | Error,\n    stack?: string\n  ): void {\n    if (\n      NumericLogLevels[this.config(\"level\") as LogLevel] <\n      NumericLogLevels[level]\n    )\n      return;\n    let method;\n    switch (level) {\n      case LogLevel.info:\n        method = console.log;\n        break;\n      case LogLevel.verbose:\n      case LogLevel.debug:\n        method = console.debug;\n        break;\n      case LogLevel.error:\n        method = console.error;\n        break;\n      default:\n        throw new Error(\"Invalid log level\");\n    }\n    method(this.createLog(level, msg, stack));\n  }\n\n  /**\n   * @description LLogs a `way too verbose` or a silly message.\n   * @summary Logs a message at the Silly level if the current verbosity allows it.\n   *\n   * @param msg - The message to be logged.\n   * @param verbosity - The verbosity level of the message (default: 0).\n   */\n  silly(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a verbose message.\n   * @summary Logs a message at the Verbose level if the current verbosity allows it.\n   *\n   * @param msg - The message to be logged.\n   * @param verbosity - The verbosity level of the message (default: 0).\n   */\n  verbose(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs an info message.\n   * @summary Logs a message at the Info level.\n   *\n   * @param msg - The message to be logged.\n   */\n  info(msg: StringLike): void {\n    this.log(LogLevel.info, msg);\n  }\n\n  /**\n   * @description Logs a debug message.\n   * @summary Logs a message at the Debug level.\n   *\n   * @param msg - The message to be logged.\n   */\n  debug(msg: StringLike): void {\n    this.log(LogLevel.debug, msg);\n  }\n\n  /**\n   * @description Logs an error message.\n   * @summary Logs a message at the Error level.\n   *\n   * @param msg - The message to be logged.\n   */\n  error(msg: StringLike | Error): void {\n    this.log(LogLevel.error, msg);\n  }\n\n  setConfig(config: Partial<LoggingConfig>) {\n    this.conf = { ...(this.conf || {}), ...config };\n  }\n}\n\n/**\n * @description A static class for managing logging operations.\n * @summary The Logging class provides a centralized logging mechanism with support for\n * different log levels and verbosity. It uses a singleton pattern to maintain a global\n * logger instance and allows creating specific loggers for different classes and methods.\n *\n * @class\n */\nexport class Logging {\n  /**\n   * @description The global logger instance.\n   * @summary A singleton instance of VerbosityLogger used for global logging.\n   */\n  private static global?: Logger;\n\n  /**\n   * @description Factory function for creating logger instances.\n   * @summary A function that creates new VerbosityLogger instances. By default, it creates a MiniLogger.\n   */\n  private static _factory: LoggerFactory = (\n    object: string,\n    config?: Partial<LoggingConfig>\n  ) => {\n    return new MiniLogger(object, config);\n  };\n  /**\n   * @description Configuration for the logging system.\n   * @summary Stores the global verbosity level and log level settings.\n   */\n  private static _config: LoggingConfig = DefaultLoggingConfig;\n\n  /**\n   * @description Private constructor to prevent instantiation.\n   * @summary Ensures that the Logging class cannot be instantiated as it's designed to be used statically.\n   */\n  private constructor() {}\n\n  static setFactory(factory: LoggerFactory) {\n    Logging._factory = factory;\n  }\n\n  /**\n   * @description Setter for the logging configuration.\n   * @summary Allows updating the global logging configuration.\n   *\n   * @param config - An object containing verbosity and log level settings.\n   */\n  static setConfig(config: Partial<LoggingConfig>) {\n    Object.assign(this._config, config);\n  }\n\n  static getConfig(): LoggingConfig {\n    return Object.assign({}, this._config);\n  }\n\n  /**\n   * @description Retrieves or creates the global logger instance.\n   * @summary Returns the existing global logger or creates a new one if it doesn't exist.\n   *\n   * @return The global VerbosityLogger instance.\n   */\n  static get(): Logger {\n    this.global = this.global ? this.global : this._factory(\"Logging\");\n    return this.global;\n  }\n\n  /**\n   * @description Logs a verbose message.\n   * @summary Delegates the verbose logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   * @param verbosity - The verbosity level of the message (default: 0).\n   */\n  static verbose(msg: StringLike, verbosity: number = 0): void {\n    return this.get().verbose(msg, verbosity);\n  }\n\n  /**\n   * @description Logs an info message.\n   * @summary Delegates the info logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static info(msg: StringLike): void {\n    return this.get().info(msg);\n  }\n\n  /**\n   * @description Logs a debug message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static debug(msg: StringLike): void {\n    return this.get().debug(msg);\n  }\n\n  /**\n   * @description Logs a silly message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static silly(msg: StringLike): void {\n    return this.get().silly(msg);\n  }\n\n  /**\n   * @description Logs an error message.\n   * @summary Delegates the error logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static error(msg: StringLike): void {\n    return this.get().error(msg);\n  }\n\n  static for(\n    object: LoggingContext,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger {\n    object =\n      typeof object === \"string\"\n        ? object\n        : object.constructor\n          ? object.constructor.name\n          : object.name;\n    return this._factory(object, config, ...args);\n  }\n\n  /**\n   * @description Creates a logger for a specific reason or context.\n   *\n   * @summary This static method creates a new logger instance using the factory function,\n   * based on a given reason or context.\n   *\n   * @param reason - A string describing the reason or context for creating this logger.\n   * @param id\n   * @returns A new VerbosityLogger or ClassLogger instance.\n   */\n  static because(reason: string, id?: string): Logger {\n    return this._factory(reason, this._config, id);\n  }\n\n  static theme(\n    text: string,\n    type: keyof Theme | keyof LogLevel,\n    loggerLevel: LogLevel,\n    template: Theme = DefaultTheme\n  ) {\n    if (!this._config.style) return text;\n    const logger = Logging.get().for(this.theme);\n\n    function apply(\n      txt: string,\n      option: keyof ThemeOption,\n      value: number | [number] | [number, number, number] | number[] | string[]\n    ): string {\n      try {\n        const t: string | StyledString = txt;\n        let c = style(t);\n\n        function applyColor(\n          val: number | [number] | [number, number, number],\n          isBg = false\n        ): StyledString {\n          let f:\n            | typeof c.background\n            | typeof c.foreground\n            | typeof c.rgb\n            | typeof c.color256 = isBg ? c.background : c.foreground;\n          if (!Array.isArray(val)) {\n            return (f as typeof c.background | typeof c.foreground).call(\n              c,\n              value as number\n            );\n          }\n          switch (val.length) {\n            case 1:\n              f = isBg ? c.bgColor256 : c.color256;\n              return (f as typeof c.bgColor256 | typeof c.color256)(val[0]);\n            case 3:\n              f = isBg ? c.bgRgb : c.rgb;\n              return c.rgb(val[0], val[1], val[2]);\n            default:\n              logger.error(`Not a valid color option: ${option}`);\n              return style(t as string);\n          }\n        }\n\n        function applyStyle(v: number | string): void {\n          if (typeof v === \"number\") {\n            c = c.style(v);\n          } else {\n            c = c[v as keyof ColorizeOptions] as StyledString;\n          }\n        }\n\n        switch (option) {\n          case \"bg\":\n          case \"fg\":\n            return applyColor(value as number).text;\n          case \"style\":\n            if (Array.isArray(value)) {\n              value.forEach(applyStyle);\n            } else {\n              applyStyle(value as number | string);\n            }\n            return c.text;\n          default:\n            logger.error(`Not a valid theme option: ${option}`);\n            return t;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: unknown) {\n        logger.error(`Error applying style: ${option} with value ${value}`);\n        return txt;\n      }\n    }\n\n    const individualTheme = template[type as keyof Theme];\n    if (!individualTheme || !Object.keys(individualTheme).length) {\n      return text;\n    }\n\n    let actualTheme: ThemeOption = individualTheme as ThemeOption;\n\n    const logLevels = Object.assign({}, LogLevel);\n    if (Object.keys(individualTheme)[0] in logLevels)\n      actualTheme =\n        (individualTheme as ThemeOptionByLogLevel)[loggerLevel] || {};\n\n    return Object.keys(actualTheme).reduce((acc: string, key: string) => {\n      const val = (actualTheme as ThemeOption)[key as keyof ThemeOption];\n      if (val)\n        return apply(\n          acc,\n          key as keyof ThemeOption,\n          val as\n            | number\n            | [number]\n            | [number, number, number]\n            | number[]\n            | string[]\n        );\n      return acc;\n    }, text);\n  }\n}\n","import { LogLevel } from \"./constants\";\nimport { Logging } from \"./logging\";\n\nexport function log(\n  level: LogLevel = LogLevel.info,\n  benchmark: boolean = false,\n  verbosity = 0\n) {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const log = Logging.for(target).for(target[propertyKey]);\n    const method = log[level].bind(log);\n    const originalMethod = descriptor.value;\n    descriptor.value = function (...args: any[]) {\n      method(`called with ${args}`, verbosity);\n      const start = Date.now();\n      let end: number;\n      const result: any = originalMethod.apply(this, args);\n      if (result instanceof Promise) {\n        return result.then((r) => {\n          if (benchmark) {\n            end = Date.now();\n            if (benchmark) method(`completed in ${end - start}ms`, verbosity);\n          }\n          return r;\n        });\n      }\n      if (benchmark) {\n        end = Date.now();\n        if (benchmark) method(`completed in ${end - start}ms`, verbosity);\n      }\n\n      return result;\n    };\n  };\n}\n\nexport function debug(benchmark: boolean = false) {\n  return log(LogLevel.debug, benchmark);\n}\n\nexport function info(benchmark: boolean = false) {\n  return log(LogLevel.info, benchmark);\n}\n\nexport function silly(benchmark: boolean = false) {\n  return log(LogLevel.silly, benchmark);\n}\n\nexport function verbose(verbosity = 0, benchmark: boolean = false) {\n  return log(LogLevel.verbose, benchmark, verbosity);\n}\n","export * from \"./constants\";\nexport * from \"./decorators\";\nexport * from \"./logging\";\nexport * from \"./types\";\n\n/**\n * @summary Module summary\n * @description Module description\n * @module Logging\n */\n\n/**\n * @summary Logging\n * @description Namespace description\n * @namespace Logging\n * @memberOf module:Logging\n */\n\n/**\n * @summary stores the current package version\n * @description this is how you should document a constant\n * @const VERSION\n * @memberOf module:ts-workspace\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["LogLevel","LoggingMode","style"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.cjs","sources":["../src/constants.ts","../src/logging.ts","../src/decorators.ts","../src/index.ts"],"sourcesContent":["import { LoggingConfig, Theme } from \"./types\";\n\n/**\n * @description Enum for log levels.\n * @summary Defines different levels of logging for the application.\n * @enum {string}\n * @memberOf module:Logging\n */\nexport enum LogLevel {\n  /** Error events that are likely to cause problems. */\n  error = \"error\",\n  /** Routine information, such as ongoing status or performance. */\n  info = \"info\",\n  /** Additional relevant information. */\n  verbose = \"verbose\",\n  /** Debug or trace information. */\n  debug = \"debug\",\n  /** way too verbose or silly information. */\n  silly = \"silly\",\n}\n\n/**\n * @description Numeric values associated with log levels.\n * @summary Provides a numeric representation of log levels for comparison and filtering.\n * @const NumericLogLevels\n * @property {number} error - Numeric value for error level (2).\n * @property {number} info - Numeric value for info level (4).\n * @property {number} verbose - Numeric value for verbose level (6).\n * @property {number} debug - Numeric value for debug level (7).\n * @property {number} silly - Numeric value for silly level (9).\n * @memberOf module:Logging\n */\nexport const NumericLogLevels = {\n  error: 2,\n  info: 4,\n  verbose: 6,\n  debug: 7,\n  silly: 9,\n};\n\n/**\n * @description Enum for logging output modes.\n * @summary Defines different output formats for log messages.\n * @enum {string}\n * @memberOf module:Logging\n */\nexport enum LoggingMode {\n  /** Raw text format for human readability */\n  RAW = \"raw\",\n  /** JSON format for machine parsing */\n  JSON = \"json\",\n}\n\n/**\n * @description Default theme for styling log output.\n * @summary Defines the default color and style settings for various components of log messages.\n * @const DefaultTheme\n * @typedef {Theme} DefaultTheme\n * @property {Object} class - Styling for class names.\n * @property {number} class.fg - Foreground color code for class names (34).\n * @property {Object} id - Styling for identifiers.\n * @property {number} id.fg - Foreground color code for identifiers (36).\n * @property {Object} stack - Styling for stack traces (empty object).\n * @property {Object} timestamp - Styling for timestamps (empty object).\n * @property {Object} message - Styling for different types of messages.\n * @property {Object} message.error - Styling for error messages.\n * @property {number} message.error.fg - Foreground color code for error messages (31).\n * @property {Object} method - Styling for method names (empty object).\n * @property {Object} logLevel - Styling for different log levels.\n * @property {Object} logLevel.error - Styling for error level logs.\n * @property {number} logLevel.error.fg - Foreground color code for error level logs (31).\n * @property {string[]} logLevel.error.style - Style attributes for error level logs ([\"bold\"]).\n * @property {Object} logLevel.info - Styling for info level logs (empty object).\n * @property {Object} logLevel.verbose - Styling for verbose level logs (empty object).\n * @property {Object} logLevel.debug - Styling for debug level logs.\n * @property {number} logLevel.debug.fg - Foreground color code for debug level logs (33).\n * @memberOf module:Logging\n */\nexport const DefaultTheme: Theme = {\n  class: {\n    fg: 34,\n  },\n  id: {\n    fg: 36,\n  },\n  stack: {},\n  timestamp: {},\n  message: {\n    error: {\n      fg: 31,\n    },\n  },\n  method: {},\n  logLevel: {\n    error: {\n      fg: 31,\n      style: [\"bold\"],\n    },\n    info: {},\n    verbose: {},\n    debug: {\n      fg: 33,\n    },\n  },\n};\n\n/**\n * @description Default configuration for logging.\n * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.\n * @const DefaultLoggingConfig\n * @typedef {LoggingConfig} DefaultLoggingConfig\n * @property {number} verbose - Verbosity level (0).\n * @property {LogLevel} level - Default log level (LogLevel.info).\n * @property {boolean} logLevel - Whether to display log level in output (true).\n * @property {LoggingMode} mode - Output format mode (LoggingMode.RAW).\n * @property {boolean} style - Whether to apply styling to log output (false).\n * @property {string} separator - Separator between log components (\" - \").\n * @property {boolean} timestamp - Whether to include timestamps in log messages (true).\n * @property {string} timestampFormat - Format for timestamps (\"HH:mm:ss.SSS\").\n * @property {boolean} context - Whether to include context information in log messages (true).\n * @property {Theme} theme - The theme to use for styling log messages (DefaultTheme).\n * @memberOf module:Logging\n */\nexport const DefaultLoggingConfig: LoggingConfig = {\n  verbose: 0,\n  level: LogLevel.info,\n  logLevel: true,\n  mode: LoggingMode.RAW,\n  style: false,\n  contextSeparator: \".\",\n  separator: \" - \",\n  timestamp: true,\n  timestampFormat: \"HH:mm:ss.SSS\",\n  context: true,\n  theme: DefaultTheme,\n};\n","import {\n  LoggerFactory,\n  LoggingConfig,\n  LoggingContext,\n  StringLike,\n  Theme,\n  ThemeOption,\n  ThemeOptionByLogLevel,\n  Logger,\n} from \"./types\";\nimport { ColorizeOptions, style, StyledString } from \"styled-string-builder\";\nimport {\n  DefaultLoggingConfig,\n  DefaultTheme,\n  LogLevel,\n  NumericLogLevels,\n} from \"./constants\";\n\n/**\n * @description A minimal logger implementation.\n * @summary MiniLogger is a lightweight logging class that implements the Logger interface.\n * It provides basic logging functionality with support for different log levels, verbosity,\n * context-aware logging, and customizable formatting.\n * @param {string} context - The context (typically class name) this logger is associated with\n * @param {Partial<LoggingConfig>} conf - Optional configuration to override global settings\n * @class MiniLogger\n * @example\n * // Create a new logger for a class\n * const logger = new MiniLogger('MyClass');\n *\n * // Log messages at different levels\n * logger.info('This is an info message');\n * logger.debug('This is a debug message');\n * logger.error('Something went wrong');\n *\n * // Create a child logger for a specific method\n * const methodLogger = logger.for('myMethod');\n * methodLogger.verbose('Detailed information', 2);\n *\n * // Log with custom configuration\n * logger.for('specialMethod', { style: true }).info('Styled message');\n */\nexport class MiniLogger implements Logger {\n  constructor(\n    protected context: string,\n    protected conf?: Partial<LoggingConfig>\n  ) {}\n\n  protected config(\n    key: keyof LoggingConfig\n  ): LoggingConfig[keyof LoggingConfig] {\n    if (this.conf && key in this.conf) return this.conf[key];\n    return Logging.getConfig()[key];\n  }\n\n  /**\n   * @description Creates a child logger for a specific method or context\n   * @summary Returns a new logger instance with the current context extended by the specified method name\n   * @param {string | Function} method - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} config - Optional configuration to override settings\n   * @param {...any} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified method\n   */\n  for(\n    method?: string | ((...args: any[]) => any),\n    config?: Partial<LoggingConfig>\n  ): Logger {\n    method = method\n      ? typeof method === \"string\"\n        ? method\n        : method.name\n      : undefined;\n\n    return new Proxy(this, {\n      get: (target: typeof this, p: string | symbol, receiver: any) => {\n        const result = Reflect.get(target, p, receiver);\n        if (p === \"config\") {\n          return new Proxy(this.config, {\n            get: (target: typeof this.config, p: string | symbol) => {\n              if (config && p in config)\n                return config[p as keyof LoggingConfig];\n              return Reflect.get(target, p, receiver);\n            },\n          });\n        }\n        if (p === \"context\") {\n          return [result, method].join(\".\");\n        }\n        return result;\n      },\n    });\n  }\n\n  /**\n   * @description Creates a formatted log string\n   * @summary Generates a log string with timestamp, colored log level, context, and message\n   * @param {LogLevel} level - The log level for this message\n   * @param {StringLike | Error} message - The message to log or an Error object\n   * @param {string} [stack] - Optional stack trace to include in the log\n   * @return {string} A formatted log string with all components\n   */\n  protected createLog(\n    level: LogLevel,\n    message: StringLike | Error,\n    stack?: string\n  ): string {\n    const log: string[] = [];\n    const style = this.config(\"style\");\n    if (this.config(\"timestamp\")) {\n      const date = new Date().toISOString();\n      const timestamp = style ? Logging.theme(date, \"timestamp\", level) : date;\n      log.push(timestamp);\n    }\n\n    if (this.config(\"logLevel\")) {\n      const lvl: string = style\n        ? Logging.theme(level, \"logLevel\", level)\n        : level;\n      log.push(lvl);\n    }\n\n    if (this.config(\"context\")) {\n      const context: string = style\n        ? Logging.theme(this.context, \"class\", level)\n        : this.context;\n      log.push(context);\n    }\n\n    if (this.config(\"correlationId\")) {\n      {\n        const id: string = style\n          ? Logging.theme(this.config(\"correlationId\")!.toString(), \"id\", level)\n          : this.config(\"correlationId\")!.toString();\n        log.push(id);\n      }\n    }\n\n    const msg: string = style\n      ? Logging.theme(\n          typeof message === \"string\" ? message : (message as Error).message,\n          \"message\",\n          level\n        )\n      : typeof message === \"string\"\n        ? message\n        : (message as Error).message;\n    log.push(msg);\n    if (stack || message instanceof Error) {\n      stack = style\n        ? Logging.theme(\n            (stack || (message as Error).stack) as string,\n            \"stack\",\n            level\n          )\n        : stack;\n      log.push(`\\nStack trace:\\n${stack}`);\n    }\n\n    return log.join(this.config(\"separator\") as string);\n  }\n\n  /**\n   * @description Logs a message with the specified log level\n   * @summary Checks if the message should be logged based on the current log level,\n   * then uses the appropriate console method to output the formatted log\n   * @param {LogLevel} level - The log level of the message\n   * @param {StringLike | Error} msg - The message to be logged or an Error object\n   * @param {string} [stack] - Optional stack trace to include in the log\n   * @return {void}\n   */\n  protected log(\n    level: LogLevel,\n    msg: StringLike | Error,\n    stack?: string\n  ): void {\n    if (\n      NumericLogLevels[this.config(\"level\") as LogLevel] <\n      NumericLogLevels[level]\n    )\n      return;\n    let method;\n    switch (level) {\n      case LogLevel.info:\n        method = console.log;\n        break;\n      case LogLevel.verbose:\n      case LogLevel.debug:\n        method = console.debug;\n        break;\n      case LogLevel.error:\n        method = console.error;\n        break;\n      default:\n        throw new Error(\"Invalid log level\");\n    }\n    method(this.createLog(level, msg, stack));\n  }\n\n  /**\n   * @description Logs a message at the silly level\n   * @summary Logs a message at the silly level if the current verbosity setting allows it\n   * @param {StringLike} msg - The message to be logged\n   * @param {number} [verbosity=0] - The verbosity level of the message\n   * @return {void}\n   */\n  silly(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a message at the verbose level\n   * @summary Logs a message at the verbose level if the current verbosity setting allows it\n   * @param {StringLike} msg - The message to be logged\n   * @param {number} [verbosity=0] - The verbosity level of the message\n   * @return {void}\n   */\n  verbose(msg: StringLike, verbosity: number = 0): void {\n    if ((this.config(\"verbose\") as number) >= verbosity)\n      this.log(LogLevel.verbose, msg);\n  }\n\n  /**\n   * @description Logs a message at the info level\n   * @summary Logs a message at the info level for general application information\n   * @param {StringLike} msg - The message to be logged\n   * @return {void}\n   */\n  info(msg: StringLike): void {\n    this.log(LogLevel.info, msg);\n  }\n\n  /**\n   * @description Logs a message at the debug level\n   * @summary Logs a message at the debug level for detailed troubleshooting information\n   * @param {StringLike} msg - The message to be logged\n   * @return {void}\n   */\n  debug(msg: StringLike): void {\n    this.log(LogLevel.debug, msg);\n  }\n\n  /**\n   * @description Logs a message at the error level\n   * @summary Logs a message at the error level for errors and exceptions\n   * @param {StringLike | Error} msg - The message to be logged or an Error object\n   * @return {void}\n   */\n  error(msg: StringLike | Error): void {\n    this.log(LogLevel.error, msg);\n  }\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Merges the provided configuration with the existing configuration\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   * @return {void}\n   */\n  setConfig(config: Partial<LoggingConfig>): void {\n    this.conf = { ...(this.conf || {}), ...config };\n  }\n}\n\n/**\n * @description A static class for managing logging operations\n * @summary The Logging class provides a centralized logging mechanism with support for\n * different log levels, verbosity, and styling. It uses a singleton pattern to maintain a global\n * logger instance and allows creating specific loggers for different classes and methods.\n * @class Logging\n * @example\n * // Set global configuration\n * Logging.setConfig({ level: LogLevel.debug, style: true });\n *\n * // Get a logger for a specific class\n * const logger = Logging.for('MyClass');\n *\n * // Log messages at different levels\n * logger.info('Application started');\n * logger.debug('Processing data...');\n *\n * // Log with context\n * const methodLogger = Logging.for('MyClass.myMethod');\n * methodLogger.verbose('Detailed operation information', 1);\n *\n * // Log errors\n * try {\n *   // some operation\n * } catch (error) {\n *   logger.error(error);\n * }\n * @mermaid\n * classDiagram\n *   class Logger {\n *     <<interface>>\n *     +for(method, config, ...args)\n *     +silly(msg, verbosity)\n *     +verbose(msg, verbosity)\n *     +info(msg)\n *     +debug(msg)\n *     +error(msg)\n *     +setConfig(config)\n *   }\n *\n *   class Logging {\n *     -global: Logger\n *     -_factory: LoggerFactory\n *     -_config: LoggingConfig\n *     +setFactory(factory)\n *     +setConfig(config)\n *     +getConfig()\n *     +get()\n *     +verbose(msg, verbosity)\n *     +info(msg)\n *     +debug(msg)\n *     +silly(msg)\n *     +error(msg)\n *     +for(object, config, ...args)\n *     +because(reason, id)\n *     +theme(text, type, loggerLevel, template)\n *   }\n *\n *   class MiniLogger {\n *     +constructor(context, conf?)\n *   }\n *\n *   Logging ..> Logger : creates\n *   Logging ..> MiniLogger : creates by default\n */\nexport class Logging {\n  /**\n   * @description The global logger instance\n   * @summary A singleton instance of Logger used for global logging\n   */\n  private static global?: Logger;\n\n  /**\n   * @description Factory function for creating logger instances\n   * @summary A function that creates new Logger instances. By default, it creates a MiniLogger.\n   */\n  private static _factory: LoggerFactory = (\n    object: string,\n    config?: Partial<LoggingConfig>\n  ) => {\n    return new MiniLogger(object, config);\n  };\n  /**\n   * @description Configuration for the logging system\n   * @summary Stores the global logging configuration including verbosity, log level, styling, and formatting settings\n   */\n  private static _config: LoggingConfig = DefaultLoggingConfig;\n\n  private constructor() {}\n\n  /**\n   * @description Sets the factory function for creating logger instances\n   * @summary Allows customizing how logger instances are created\n   * @param {LoggerFactory} factory - The factory function to use for creating loggers\n   * @return {void}\n   */\n  static setFactory(factory: LoggerFactory) {\n    Logging._factory = factory;\n  }\n\n  /**\n   * @description Updates the global logging configuration\n   * @summary Allows updating the global logging configuration with new settings\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   * @return {void}\n   */\n  static setConfig(config: Partial<LoggingConfig>) {\n    Object.assign(this._config, config);\n  }\n\n  /**\n   * @description Gets a copy of the current global logging configuration\n   * @summary Returns a copy of the current global logging configuration\n   * @return {LoggingConfig} A copy of the current configuration\n   */\n  static getConfig(): LoggingConfig {\n    return Object.assign({}, this._config);\n  }\n\n  /**\n   * @description Retrieves or creates the global logger instance.\n   * @summary Returns the existing global logger or creates a new one if it doesn't exist.\n   *\n   * @return The global VerbosityLogger instance.\n   */\n  static get(): Logger {\n    this.global = this.global ? this.global : this._factory(\"Logging\");\n    return this.global;\n  }\n\n  /**\n   * @description Logs a verbose message.\n   * @summary Delegates the verbose logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   * @param verbosity - The verbosity level of the message (default: 0).\n   */\n  static verbose(msg: StringLike, verbosity: number = 0): void {\n    return this.get().verbose(msg, verbosity);\n  }\n\n  /**\n   * @description Logs an info message.\n   * @summary Delegates the info logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static info(msg: StringLike): void {\n    return this.get().info(msg);\n  }\n\n  /**\n   * @description Logs a debug message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static debug(msg: StringLike): void {\n    return this.get().debug(msg);\n  }\n\n  /**\n   * @description Logs a silly message.\n   * @summary Delegates the debug logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static silly(msg: StringLike): void {\n    return this.get().silly(msg);\n  }\n\n  /**\n   * @description Logs an error message.\n   * @summary Delegates the error logging to the global logger instance.\n   *\n   * @param msg - The message to be logged.\n   */\n  static error(msg: StringLike): void {\n    return this.get().error(msg);\n  }\n\n  /**\n   * @description Creates a logger for a specific object or context\n   * @summary Creates a new logger instance for the given object or context using the factory function\n   * @param {LoggingContext} object - The object, class, or context to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration to override global settings\n   * @param {...any} args - Additional arguments to pass to the logger factory\n   * @return {Logger} A new logger instance for the specified object or context\n   */\n  static for(\n    object: LoggingContext,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger {\n    object =\n      typeof object === \"string\"\n        ? object\n        : object.constructor\n          ? object.constructor.name\n          : object.name;\n    return this._factory(object, config, ...args);\n  }\n\n  /**\n   * @description Creates a logger for a specific reason or context.\n   *\n   * @summary This static method creates a new logger instance using the factory function,\n   * based on a given reason or context.\n   *\n   * @param reason - A string describing the reason or context for creating this logger.\n   * @param id\n   * @returns A new VerbosityLogger or ClassLogger instance.\n   */\n  static because(reason: string, id?: string): Logger {\n    return this._factory(reason, this._config, id);\n  }\n\n  /**\n   * @description Applies theme styling to text\n   * @summary Applies styling (colors, formatting) to text based on the theme configuration\n   * @param {string} text - The text to style\n   * @param {string} type - The type of element to style (e.g., \"class\", \"message\", \"logLevel\")\n   * @param {LogLevel} loggerLevel - The log level to use for styling\n   * @param {Theme} [template=DefaultTheme] - The theme to use for styling\n   * @return {string} The styled text\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant Theme as Logging.theme\n   *   participant Apply as apply function\n   *   participant Style as styled-string-builder\n   *\n   *   Caller->>Theme: theme(text, type, loggerLevel)\n   *   Theme->>Theme: Check if styling is enabled\n   *   alt styling disabled\n   *     Theme-->>Caller: return original text\n   *   else styling enabled\n   *     Theme->>Theme: Get theme for type\n   *     alt theme not found\n   *       Theme-->>Caller: return original text\n   *     else theme found\n   *       Theme->>Theme: Determine actual theme based on log level\n   *       Theme->>Apply: Apply each style property\n   *       Apply->>Style: Apply colors and formatting\n   *       Style-->>Apply: Return styled text\n   *       Apply-->>Theme: Return styled text\n   *       Theme-->>Caller: Return final styled text\n   *     end\n   *   end\n   */\n  static theme(\n    text: string,\n    type: keyof Theme | keyof LogLevel,\n    loggerLevel: LogLevel,\n    template: Theme = DefaultTheme\n  ) {\n    if (!this._config.style) return text;\n    const logger = Logging.get().for(this.theme);\n\n    function apply(\n      txt: string,\n      option: keyof ThemeOption,\n      value: number | [number] | [number, number, number] | number[] | string[]\n    ): string {\n      try {\n        const t: string | StyledString = txt;\n        let c = style(t);\n\n        function applyColor(\n          val: number | [number] | [number, number, number],\n          isBg = false\n        ): StyledString {\n          let f:\n            | typeof c.background\n            | typeof c.foreground\n            | typeof c.rgb\n            | typeof c.color256 = isBg ? c.background : c.foreground;\n          if (!Array.isArray(val)) {\n            return (f as typeof c.background | typeof c.foreground).call(\n              c,\n              value as number\n            );\n          }\n          switch (val.length) {\n            case 1:\n              f = isBg ? c.bgColor256 : c.color256;\n              return (f as typeof c.bgColor256 | typeof c.color256)(val[0]);\n            case 3:\n              f = isBg ? c.bgRgb : c.rgb;\n              return c.rgb(val[0], val[1], val[2]);\n            default:\n              logger.error(`Not a valid color option: ${option}`);\n              return style(t as string);\n          }\n        }\n\n        function applyStyle(v: number | string): void {\n          if (typeof v === \"number\") {\n            c = c.style(v);\n          } else {\n            c = c[v as keyof ColorizeOptions] as StyledString;\n          }\n        }\n\n        switch (option) {\n          case \"bg\":\n          case \"fg\":\n            return applyColor(value as number).text;\n          case \"style\":\n            if (Array.isArray(value)) {\n              value.forEach(applyStyle);\n            } else {\n              applyStyle(value as number | string);\n            }\n            return c.text;\n          default:\n            logger.error(`Not a valid theme option: ${option}`);\n            return t;\n        }\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      } catch (e: unknown) {\n        logger.error(`Error applying style: ${option} with value ${value}`);\n        return txt;\n      }\n    }\n\n    const individualTheme = template[type as keyof Theme];\n    if (!individualTheme || !Object.keys(individualTheme).length) {\n      return text;\n    }\n\n    let actualTheme: ThemeOption = individualTheme as ThemeOption;\n\n    const logLevels = Object.assign({}, LogLevel);\n    if (Object.keys(individualTheme)[0] in logLevels)\n      actualTheme =\n        (individualTheme as ThemeOptionByLogLevel)[loggerLevel] || {};\n\n    return Object.keys(actualTheme).reduce((acc: string, key: string) => {\n      const val = (actualTheme as ThemeOption)[key as keyof ThemeOption];\n      if (val)\n        return apply(\n          acc,\n          key as keyof ThemeOption,\n          val as\n            | number\n            | [number]\n            | [number, number, number]\n            | number[]\n            | string[]\n        );\n      return acc;\n    }, text);\n  }\n}\n","import { LogLevel } from \"./constants\";\nimport { Logging } from \"./logging\";\n\n/**\n * @description Method decorator for logging function calls\n * @summary Creates a decorator that logs method calls with specified level, benchmarking, and verbosity\n * @param {LogLevel} level - The log level to use (default: LogLevel.info)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @param {number} [verbosity=0] - The verbosity level for the log messages (default: 0)\n * @return {Function} A method decorator that wraps the original method with logging\n * @function log\n * @category Decorators\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Decorator as log decorator\n *   participant Method as Original Method\n *   participant Logger as Logging instance\n *\n *   Client->>Decorator: call decorated method\n *   Decorator->>Logger: log method call\n *   Decorator->>Method: call original method\n *   alt result is Promise\n *     Method-->>Decorator: return Promise\n *     Decorator->>Decorator: attach then handler\n *     Note over Decorator: Promise resolves\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   else result is not Promise\n *     Method-->>Decorator: return result\n *     Decorator->>Logger: log benchmark (if enabled)\n *     Decorator-->>Client: return result\n *   end\n */\nexport function log(\n  level: LogLevel = LogLevel.info,\n  benchmark: boolean = false,\n  verbosity = 0\n) {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const log = Logging.for(target).for(target[propertyKey]);\n    const method = log[level].bind(log);\n    const originalMethod = descriptor.value;\n    descriptor.value = function (...args: any[]) {\n      method(`called with ${args}`, verbosity);\n      const start = Date.now();\n      let end: number;\n      const result: any = originalMethod.apply(this, args);\n      if (result instanceof Promise) {\n        return result.then((r) => {\n          if (benchmark) {\n            end = Date.now();\n            if (benchmark) method(`completed in ${end - start}ms`, verbosity);\n          }\n          return r;\n        });\n      }\n      if (benchmark) {\n        end = Date.now();\n        if (benchmark) method(`completed in ${end - start}ms`, verbosity);\n      }\n\n      return result;\n    };\n  };\n}\n\n/**\n * @description Method decorator for logging function calls with debug level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.debug\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with debug logging\n * @function debug\n * @category Decorators\n */\nexport function debug(benchmark: boolean = false) {\n  return log(LogLevel.debug, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with info level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.info\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with info logging\n * @function info\n * @category Decorators\n */\nexport function info(benchmark: boolean = false) {\n  return log(LogLevel.info, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with silly level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.silly\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with silly logging\n * @function silly\n * @category Decorators\n */\nexport function silly(benchmark: boolean = false) {\n  return log(LogLevel.silly, benchmark);\n}\n\n/**\n * @description Method decorator for logging function calls with verbose level\n * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity\n * @param {number} verbosity - The verbosity level for the log messages (default: 0)\n * @param {boolean} [benchmark=false] - Whether to log execution time (default: false)\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Decorators\n */\nexport function verbose(verbosity = 0, benchmark: boolean = false) {\n  return log(LogLevel.verbose, benchmark, verbosity);\n}\n","export * from \"./constants\";\nexport * from \"./decorators\";\nexport * from \"./logging\";\nexport * from \"./types\";\n\n/**\n * @description A logging module for TypeScript applications\n * @summary This module provides a comprehensive logging solution for TypeScript applications. It exports constants, decorators, logging utilities, and type definitions to facilitate structured logging.\n * @module Logging\n */\n\n/**\n * @description Current package version string\n * @summary Stores the current package version, used for version tracking and compatibility checks\n * @const VERSION\n * @memberOf module:Logging\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["LogLevel","LoggingMode","style"],"mappings":"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"}