@decaf-ts/logging 0.1.0 → 0.2.1

package/dist/logging.cjs

@@ -1,151 +1,484 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.logging = {}));
-})(this, (function (exports) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('styled-string-builder')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'styled-string-builder'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.logging = {}, global.styledStringBuilder));
+})(this, (function (exports, styledStringBuilder) { 'use strict';
 
+    /**
+     * @description Enum for log levels.
+     * @summary Defines different levels of logging for the application.
+     * @enum {string}
+     * @memberOf @decaf-ts/utils
+     */
     exports.LogLevel = void 0;
     (function (LogLevel) {
-        LogLevel["Fatal"] = "fatal";
-        LogLevel["Error"] = "error";
-        LogLevel["Warn"] = "warn";
-        LogLevel["Info"] = "info";
-        LogLevel["Http"] = "http";
-        LogLevel["Verbose"] = "verbose";
-        LogLevel["Debug"] = "debug";
-        LogLevel["Silly"] = "silly";
+        /** Error events that are likely to cause problems. */
+        LogLevel["error"] = "error";
+        /** Routine information, such as ongoing status or performance. */
+        LogLevel["info"] = "info";
+        /** Additional relevant information. */
+        LogLevel["verbose"] = "verbose";
+        /** Debug or trace information. */
+        LogLevel["debug"] = "debug";
+        /** way too verbose or silly information. */
+        LogLevel["silly"] = "silly";
     })(exports.LogLevel || (exports.LogLevel = {}));
+    /**
+     * @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 = {
-        error: 0,
-        warn: 1,
-        info: 2,
-        http: 3,
-        verbose: 4,
-        debug: 5,
-        silly: 6,
+        error: 2,
+        info: 4,
+        verbose: 6,
+        debug: 7,
+        silly: 9,
+    };
+    exports.LoggingMode = void 0;
+    (function (LoggingMode) {
+        LoggingMode["RAW"] = "raw";
+        LoggingMode["JSON"] = "json";
+    })(exports.LoggingMode || (exports.LoggingMode = {}));
+    /**
+     * @description Default theme for styling log output.
+     * @summary Defines the default color and style settings for various components of log messages.
+     * @const DefaultTheme
+     * @typedef {Theme} DefaultTheme
+     * @property {Object} class - Styling for class names.
+     * @property {number} class.fg - Foreground color code for class names (4).
+     * @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 {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 {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
+     */
+    const DefaultTheme = {
+        class: {
+            fg: 34,
+        },
+        id: {
+            fg: 36,
+        },
+        stack: {},
+        timestamp: {},
+        message: {
+            error: {
+                fg: 31,
+            },
+        },
+        method: {},
+        logLevel: {
+            error: {
+                fg: 31,
+                style: ["bold"],
+            },
+            info: {},
+            verbose: {},
+            debug: {
+                fg: 33,
+            },
+        },
+    };
+    /**
+     * @description Default configuration for logging.
+     * @summary Defines the default settings for the logging system, including verbosity, log level, styling, and timestamp format.
+     * @const DefaultLoggingConfig
+     * @typedef {LoggingConfig} DefaultLoggingConfig
+     * @property {number} verbose - Verbosity level (0).
+     * @property {LogLevel} level - Default log level (LogLevel.info).
+     * @property {boolean} style - Whether to apply styling to log output (false).
+     * @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
+     */
+    const DefaultLoggingConfig = {
+        verbose: 0,
+        level: exports.LogLevel.info,
+        logLevel: true,
+        mode: exports.LoggingMode.RAW,
+        style: false,
+        separator: " - ",
+        timestamp: true,
+        timestampFormat: "HH:mm:ss.SSS",
+        context: true,
+        theme: DefaultTheme,
     };
 
-    class LoggerFactory {
-        constructor(level) {
-            this.level = level;
+    /**
+     * @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.
+     *
+     * @class
+     */
+    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, id) {
+            this.context = context;
+            this.conf = conf;
+            this.id = id;
         }
-    }
-
-    function toLogLevel(level) {
-        if (level.toString() in NumericLogLevels) {
-            return NumericLogLevels[level.toString()];
+        config(key) {
+            if (this.conf && key in this.conf)
+                return this.conf[key];
+            return Logging.getConfig()[key];
         }
-        throw new Error(`Invalid level: ${level.toString()}`);
-    }
-
-    class DefaultLogger {
-        constructor(level, clazz, method) {
-            this.level = level;
-            this.clazz = clazz;
-            this.method = method;
-        }
-        log(level, message, data, profile) {
-            if (toLogLevel(level) < toLogLevel(this.level))
+        for(method, config) {
+            method = method
+                ? typeof method === "string"
+                    ? method
+                    : method.name
+                : undefined;
+            return Logging.for([this.context, method].join("."), this.id, config);
+        }
+        /**
+         * @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.
+         */
+        createLog(level, message, stack) {
+            const log = [];
+            const style = this.config("style");
+            if (this.config("timestamp")) {
+                const date = new Date().toISOString();
+                const timestamp = style ? Logging.theme(date, "timestamp", level) : date;
+                log.push(timestamp);
+            }
+            if (this.config("logLevel")) {
+                const lvl = style
+                    ? Logging.theme(level, "logLevel", level)
+                    : level;
+                log.push(lvl);
+            }
+            if (this.config("context")) {
+                const context = style
+                    ? Logging.theme(this.context, "class", level)
+                    : this.context;
+                log.push(context);
+            }
+            if (this.id) {
+                {
+                    const id = style
+                        ? Logging.theme(this.id, "id", level)
+                        : this.id;
+                    log.push(id);
+                }
+            }
+            const msg = style
+                ? Logging.theme(typeof message === "string" ? message : message.message, "message", level)
+                : typeof message === "string"
+                    ? message
+                    : message.message;
+            log.push(msg);
+            if (stack || message instanceof Error) {
+                stack = style
+                    ? Logging.theme((stack || message.stack), "stack", level)
+                    : stack;
+                log.push(`\nStack trace:\n${stack}`);
+            }
+            return log.join(this.config("separator"));
+        }
+        /**
+         * @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
+         */
+        log(level, msg, stack) {
+            if (NumericLogLevels[this.config("level")] <
+                NumericLogLevels[level])
                 return;
-            const { context, app } = data || {};
-            const msg = `${profile ? `[${profile}]` : ""}${app ? `[${app}]` : ""}${context ? `[${context}]` : ""}${this.clazz ? `[${this.clazz}]` : ""}${this.method ? `[${this.method}]` : ""} ${message}`;
+            let method;
             switch (level) {
-                case exports.LogLevel.Fatal:
-                case exports.LogLevel.Error:
-                    return console.error(msg);
-                case exports.LogLevel.Warn:
-                    return console.warn(msg);
-                case exports.LogLevel.Info:
-                    return console.info(msg);
-                case exports.LogLevel.Http:
-                case exports.LogLevel.Verbose:
-                case exports.LogLevel.Debug:
-                case exports.LogLevel.Silly:
-                    return console.debug(msg);
+                case exports.LogLevel.info:
+                    method = console.log;
+                    break;
+                case exports.LogLevel.verbose:
+                case exports.LogLevel.debug:
+                    method = console.debug;
+                    break;
+                case exports.LogLevel.error:
+                    method = console.error;
+                    break;
                 default:
-                    throw new Error(`Invalid log level: ${level}`);
+                    throw new Error("Invalid log level");
             }
+            method(this.createLog(level, msg, stack));
         }
-        silly(message, data, profile) {
-            return this.log(exports.LogLevel.Silly, message, data, profile);
+        /**
+         * @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).
+         */
+        silly(msg, verbosity = 0) {
+            if (this.config("verbose") >= verbosity)
+                this.log(exports.LogLevel.verbose, msg);
         }
-        verbose(message, data, profile) {
-            return this.log(exports.LogLevel.Verbose, message, data, profile);
+        /**
+         * @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).
+         */
+        verbose(msg, verbosity = 0) {
+            if (this.config("verbose") >= verbosity)
+                this.log(exports.LogLevel.verbose, msg);
         }
-        debug(message, data, profile) {
-            return this.log(exports.LogLevel.Debug, message, data, profile);
+        /**
+         * @description Logs an info message.
+         * @summary Logs a message at the Info level.
+         *
+         * @param msg - The message to be logged.
+         */
+        info(msg) {
+            this.log(exports.LogLevel.info, msg);
         }
-        info(message, data, profile) {
-            return this.log(exports.LogLevel.Info, message, data, profile);
+        /**
+         * @description Logs a debug message.
+         * @summary Logs a message at the Debug level.
+         *
+         * @param msg - The message to be logged.
+         */
+        debug(msg) {
+            this.log(exports.LogLevel.debug, msg);
         }
-        warn(message, data, profile) {
-            return this.log(exports.LogLevel.Warn, message, data, profile);
+        /**
+         * @description Logs an error message.
+         * @summary Logs a message at the Error level.
+         *
+         * @param msg - The message to be logged.
+         */
+        error(msg) {
+            this.log(exports.LogLevel.error, msg);
         }
-        error(message, data, profile) {
-            return this.log(exports.LogLevel.Error, message, data, profile);
+        setConfig(config) {
+            this.conf = { ...(this.conf || {}), ...config };
         }
-        emerg(message, data, profile) {
-            return this.log(exports.LogLevel.Fatal, message, data, profile);
+    }
+    /**
+     * @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
+     * logger instance and allows creating specific loggers for different classes and methods.
+     *
+     * @class
+     */
+    class Logging {
+        /**
+         * @description Factory function for creating logger instances.
+         * @summary A function that creates new VerbosityLogger instances. By default, it creates a MiniLogger.
+         */
+        static { this._factory = (object, config, id) => {
+            return new MiniLogger(object, config, id);
+        }; }
+        /**
+         * @description Configuration for the logging system.
+         * @summary Stores the global verbosity level and log level settings.
+         */
+        static { this._config = DefaultLoggingConfig; }
+        /**
+         * @description Private constructor to prevent instantiation.
+         * @summary Ensures that the Logging class cannot be instantiated as it's designed to be used statically.
+         */
+        constructor() { }
+        setFactory(factory) {
+            Logging._factory = factory;
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        profile(id, meta) {
-            throw new Error("Not implemented");
+        /**
+         * @description Setter for the logging configuration.
+         * @summary Allows updating the global logging configuration.
+         *
+         * @param config - An object containing verbosity and log level settings.
+         */
+        static setConfig(config) {
+            Object.assign(this._config, config);
         }
-    }
-    class DefaultLoggerFactory extends LoggerFactory {
-        constructor(level) {
-            super(level);
+        static getConfig() {
+            return Object.assign({}, this._config);
         }
-        forClass(clazz) {
-            return new DefaultLogger(this.level, clazz.name);
+        /**
+         * @description Retrieves or creates the global logger instance.
+         * @summary Returns the existing global logger or creates a new one if it doesn't exist.
+         *
+         * @return The global VerbosityLogger instance.
+         */
+        static get() {
+            this.global = this.global ? this.global : this._factory("Logging");
+            return this.global;
         }
-        forMethod(clazz, method) {
-            return new DefaultLogger(this.level, clazz.name, typeof method === "string" ? method : method.name);
+        /**
+         * @description Logs a verbose message.
+         * @summary Delegates the verbose logging to the global logger instance.
+         *
+         * @param msg - The message to be logged.
+         * @param verbosity - The verbosity level of the message (default: 0).
+         */
+        static verbose(msg, verbosity = 0) {
+            return this.get().verbose(msg, verbosity);
         }
-        get() {
-            return new DefaultLogger(this.level);
+        /**
+         * @description Logs an info message.
+         * @summary Delegates the info logging to the global logger instance.
+         *
+         * @param msg - The message to be logged.
+         */
+        static info(msg) {
+            return this.get().info(msg);
         }
-    }
-
-    class Logging {
-        static { this._level = exports.LogLevel.Info; }
-        static { this._factory = DefaultLoggerFactory; }
-        static { this.cacheByClass = {}; }
-        static { this.cacheByClassMethod = {}; }
-        constructor() { }
-        static get level() {
-            return this._level;
-        }
-        static set level(level) {
-            this._level = level;
-        }
-        static get instance() {
-            if (!this._instance)
-                this._instance = new this._factory(Logging.level);
-            return this._instance;
-        }
-        static set factory(factory) {
-            this._factory = factory;
-        }
-        static forClass(clazz) {
-            const name = clazz.name;
-            if (!(name in this.cacheByClass))
-                this.cacheByClass[name] = Logging.instance.forClass(clazz);
-            return this.cacheByClass[name];
-        }
-        static forMethod(clazz, method) {
-            const name = clazz.name;
-            if (!(name in this.cacheByClassMethod))
-                this.cacheByClassMethod[name] = {};
-            const methodName = typeof method === "string" ? method : method.name;
-            if (!(methodName in this.cacheByClassMethod[name]))
-                this.cacheByClassMethod[name][methodName] = Logging.instance.forMethod(clazz, method);
-            return this.cacheByClassMethod[name][methodName];
+        /**
+         * @description Logs a debug message.
+         * @summary Delegates the debug logging to the global logger instance.
+         *
+         * @param msg - The message to be logged.
+         */
+        static debug(msg) {
+            return this.get().debug(msg);
         }
-        static get() {
-            if (!this.global)
-                this.global = Logging.instance.get();
-            return this.global;
+        /**
+         * @description Logs a silly message.
+         * @summary Delegates the debug logging to the global logger instance.
+         *
+         * @param msg - The message to be logged.
+         */
+        static silly(msg) {
+            return this.get().silly(msg);
+        }
+        /**
+         * @description Logs an error message.
+         * @summary Delegates the error logging to the global logger instance.
+         *
+         * @param msg - The message to be logged.
+         */
+        static error(msg) {
+            return this.get().error(msg);
+        }
+        static for(object, id, config) {
+            object = typeof object === "string" ? object : object.name;
+            id = typeof id === "string" ? id : undefined;
+            config = typeof id === "object" ? id : config;
+            return this._factory(object, config, id);
+        }
+        /**
+         * @description Creates a logger for a specific reason or context.
+         *
+         * @summary This static method creates a new logger instance using the factory function,
+         * based on a given reason or context.
+         *
+         * @param reason - A string describing the reason or context for creating this logger.
+         * @param id
+         * @returns A new VerbosityLogger or ClassLogger instance.
+         */
+        static because(reason, id) {
+            return this._factory(reason, this._config, id);
+        }
+        static theme(text, type, loggerLevel, template = DefaultTheme) {
+            if (!this._config.style)
+                return text;
+            const logger = Logging.get().for(this.theme);
+            function apply(txt, option, value) {
+                try {
+                    const t = txt;
+                    let c = styledStringBuilder.style(t);
+                    function applyColor(val, isBg = false) {
+                        let f = isBg ? c.background : c.foreground;
+                        if (!Array.isArray(val)) {
+                            return f.call(c, value);
+                        }
+                        switch (val.length) {
+                            case 1:
+                                f = isBg ? c.bgColor256 : c.color256;
+                                return f(val[0]);
+                            case 3:
+                                f = isBg ? c.bgRgb : c.rgb;
+                                return c.rgb(val[0], val[1], val[2]);
+                            default:
+                                logger.error(`Not a valid color option: ${option}`);
+                                return styledStringBuilder.style(t);
+                        }
+                    }
+                    function applyStyle(v) {
+                        if (typeof v === "number") {
+                            c = c.style(v);
+                        }
+                        else {
+                            c = c[v];
+                        }
+                    }
+                    switch (option) {
+                        case "bg":
+                        case "fg":
+                            return applyColor(value).text;
+                        case "style":
+                            if (Array.isArray(value)) {
+                                value.forEach(applyStyle);
+                            }
+                            else {
+                                applyStyle(value);
+                            }
+                            return c.text;
+                        default:
+                            logger.error(`Not a valid theme option: ${option}`);
+                            return t;
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) {
+                    logger.error(`Error applying style: ${option} with value ${value}`);
+                    return txt;
+                }
+            }
+            const individualTheme = template[type];
+            if (!individualTheme || !Object.keys(individualTheme).length) {
+                return text;
+            }
+            let actualTheme = individualTheme;
+            const logLevels = Object.assign({}, exports.LogLevel);
+            if (Object.keys(individualTheme)[0] in logLevels)
+                actualTheme =
+                    individualTheme[loggerLevel] || {};
+            return Object.keys(actualTheme).reduce((acc, key) => {
+                const val = actualTheme[key];
+                if (val)
+                    return apply(acc, key, val);
+                return acc;
+            }, text);
         }
     }
 
@@ -166,14 +499,14 @@
      * @const VERSION
      * @memberOf module:ts-workspace
      */
-    const VERSION = "0.1.0";
+    const VERSION = "0.2.1";
 
-    exports.DefaultLoggerFactory = DefaultLoggerFactory;
-    exports.LoggerFactory = LoggerFactory;
+    exports.DefaultLoggingConfig = DefaultLoggingConfig;
+    exports.DefaultTheme = DefaultTheme;
     exports.Logging = Logging;
+    exports.MiniLogger = MiniLogger;
     exports.NumericLogLevels = NumericLogLevels;
     exports.VERSION = VERSION;
-    exports.toLogLevel = toLogLevel;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"logging.cjs","sources":["../src/constants.ts","../src/Factory.ts","../src/utils.ts","../src/default.ts","../src/logging.ts","../src/index.ts"],"sourcesContent":["export enum LogLevel {\n  Fatal = \"fatal\", // A person must take an action immediately\n  Error = \"error\", // Error events are likely to cause problems\n  Warn = \"warn\", // Warning events might cause problems in the future and deserve eyes\n  Info = \"info\", // Routine information, such as ongoing status or performance\n  Http = \"http\", // Http information\n  Verbose = \"verbose\", // Debug or trace information\n  Debug = \"debug\", // Debug or trace information\n  Silly = \"silly\", // Debug or trace information\n}\n\nexport const NumericLogLevels = {\n  error: 0,\n  warn: 1,\n  info: 2,\n  http: 3,\n  verbose: 4,\n  debug: 5,\n  silly: 6,\n};\n","import { Logger } from \"./interfaces\";\nimport { LogLevel } from \"./constants\";\n\nexport abstract class LoggerFactory {\n  protected constructor(protected level: LogLevel) {}\n  abstract forClass(clazz: { new (...args: any[]): any }): Logger;\n  abstract forMethod(\n    clazz: { new (...args: any[]): any },\n    method: ((...args: any[]) => any) | string\n  ): Logger;\n  abstract get(): Logger;\n}\n","import { LogLevel, NumericLogLevels } from \"./constants\";\n\nexport function toLogLevel(level: LogLevel): number {\n  if (level.toString() in NumericLogLevels) {\n    return (NumericLogLevels as Record<string, any>)[level.toString()];\n  }\n  throw new Error(`Invalid level: ${level.toString()}`);\n}\n","import { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { LogData, Logger } from \"./interfaces\";\nimport { toLogLevel } from \"./utils\";\n\nclass DefaultLogger implements Logger {\n  constructor(\n    protected level: LogLevel,\n    protected clazz?: string,\n    protected method?: string\n  ) {}\n\n  log(\n    level: LogLevel,\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    if (toLogLevel(level) < toLogLevel(this.level)) return;\n\n    const { context, app } = data || {};\n\n     \n    const msg = `${profile ? `[${profile}]` : \"\"}${app ? `[${app}]` : \"\"}${context ? `[${context}]` : \"\"}${this.clazz ? `[${this.clazz}]` : \"\"}${this.method ? `[${this.method}]` : \"\"} ${message}`;\n    switch (level) {\n    case LogLevel.Fatal:\n    case LogLevel.Error:\n      return console.error(msg);\n    case LogLevel.Warn:\n      return console.warn(msg);\n    case LogLevel.Info:\n      return console.info(msg);\n    case LogLevel.Http:\n    case LogLevel.Verbose:\n    case LogLevel.Debug:\n    case LogLevel.Silly:\n      return console.debug(msg);\n    default:\n      throw new Error(`Invalid log level: ${level}`);\n    }\n  }\n  silly(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Silly, message, data, profile);\n  }\n\n  verbose(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Verbose, message, data, profile);\n  }\n\n  debug(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Debug, message, data, profile);\n  }\n  info(\n    message: string,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Info, message, data, profile);\n  }\n  warn(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Warn, message, data, profile);\n  }\n  error(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Error, message, data, profile);\n  }\n  emerg(\n    message: string | Error,\n    data?: LogData | undefined,\n    profile?: string | undefined\n  ): void {\n    return this.log(LogLevel.Fatal, message, data, profile);\n  }\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  profile(id: string | number, meta?: Record<string, any> | undefined): void {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nexport class DefaultLoggerFactory extends LoggerFactory {\n  constructor(level: LogLevel) {\n    super(level);\n  }\n\n  forClass(clazz: new (...args: any[]) => any): Logger {\n    return new DefaultLogger(this.level, clazz.name);\n  }\n  forMethod(\n    clazz: new (...args: any[]) => any,\n    method: string | ((...args: any[]) => any)\n  ): Logger {\n    return new DefaultLogger(\n      this.level,\n      clazz.name,\n      typeof method === \"string\" ? method : method.name\n    );\n  }\n\n  get(): Logger {\n    return new DefaultLogger(this.level);\n  }\n}\n","import { Logger } from \"./interfaces\";\nimport { LoggerFactory } from \"./Factory\";\nimport { LogLevel } from \"./constants\";\nimport { DefaultLoggerFactory } from \"./default\";\n\nexport class Logging {\n  private static _level: LogLevel = LogLevel.Info;\n  private static _factory: { new (level: LogLevel): LoggerFactory } =\n    DefaultLoggerFactory;\n  private static _instance: LoggerFactory;\n\n  private static cacheByClass: Record<string, Logger> = {};\n  private static cacheByClassMethod: Record<string, Record<string, Logger>> =\n    {};\n  private static global: Logger;\n\n  private constructor() {}\n\n  static get level() {\n    return this._level;\n  }\n\n  static set level(level: LogLevel) {\n    this._level = level;\n  }\n\n  protected static get instance(): LoggerFactory {\n    if (!this._instance) this._instance = new this._factory(Logging.level);\n    return this._instance;\n  }\n\n  static set factory(factory: { new (level: LogLevel): LoggerFactory }) {\n    this._factory = factory;\n  }\n\n  static forClass(clazz: { new (...args: any[]): any }) {\n    const name = clazz.name;\n    if (!(name in this.cacheByClass))\n      this.cacheByClass[name] = Logging.instance.forClass(clazz);\n    return this.cacheByClass[name];\n  }\n\n  static forMethod(\n    clazz: { new (...args: any[]): any },\n    method: ((...args: any[]) => any) | string\n  ): Logger {\n    const name = clazz.name;\n    if (!(name in this.cacheByClassMethod)) this.cacheByClassMethod[name] = {};\n    const methodName = typeof method === \"string\" ? method : method.name;\n    if (!(methodName in this.cacheByClassMethod[name]))\n      this.cacheByClassMethod[name][methodName] = Logging.instance.forMethod(\n        clazz,\n        method\n      );\n    return this.cacheByClassMethod[name][methodName];\n  }\n\n  static get(): Logger {\n    if (!this.global) this.global = Logging.instance.get();\n    return this.global;\n  }\n}\n","export * from \"./constants\";\nexport * from \"./default\";\nexport * from \"./Factory\";\nexport * from \"./interfaces\";\nexport * from \"./logging\";\nexport * from \"./utils\";\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"],"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/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    protected id?: string\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  ): Logger {\n    method = method\n      ? typeof method === \"string\"\n        ? method\n        : method.name\n      : undefined;\n\n    return Logging.for([this.context, method].join(\".\"), this.id, config);\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.id) {\n      {\n        const id: string = style\n          ? Logging.theme(this.id, \"id\", level)\n          : this.id;\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    id?: string\n  ) => {\n    return new MiniLogger(object, config, id);\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  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    id?: string | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>\n  ): Logger {\n    object = typeof object === \"string\" ? object : object.name;\n    id = typeof id === \"string\" ? id : undefined;\n    config = typeof id === \"object\" ? (id as Partial<LoggingConfig>) : config;\n    return this._factory(object, config, id);\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","export * from \"./constants\";\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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"}