@decaf-ts/logging 0.3.6 → 0.3.8

package/lib/LoggedClass.cjs

@@ -2,11 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoggedClass = void 0;
 const logging_1 = require("./logging.cjs");
+/**
+ * @description Base class that provides a ready-to-use logger instance
+ * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
+ * into derived classes through a protected getter. Subclasses can directly access
+ * this.log to emit messages without manually creating a logger. This promotes
+ * consistent, context-aware logging across the codebase.
+ * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+ * @class LoggedClass
+ * @example
+ * class UserService extends LoggedClass {
+ *   create(user: User) {
+ *     this.log.info(`Creating user ${user.id}`);
+ *   }
+ * }
+ *
+ * const svc = new UserService();
+ * svc.create({ id: "42" });
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Instance as Subclass Instance
+ *   participant Getter as LoggedClass.log
+ *   participant Logging as Logging
+ *   participant Logger as Logger
+ *
+ *   Client->>Instance: call someMethod()
+ *   Instance->>Getter: access this.log
+ *   Getter->>Logging: Logging.for(this)
+ *   Logging-->>Getter: return Logger
+ *   Getter-->>Instance: return Logger
+ *   Instance->>Logger: info/debug/error(...)
+ */
 class LoggedClass {
+    /**
+     * @description Lazily provides a context-aware logger for the current instance
+     * @summary Uses Logging.for(this) to create a logger whose context is the
+     * subclass name, allowing uniform and structured logs from any inheriting class.
+     * @return {Logger} A logger bound to the subclass context
+     */
     get log() {
         return logging_1.Logging.for(this);
     }
     constructor() { }
 }
 exports.LoggedClass = LoggedClass;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nZ2VkQ2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvTG9nZ2VkQ2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMkNBQW9DO0FBR3BDLE1BQXNCLFdBQVc7SUFDL0IsSUFBYyxHQUFHO1FBQ2YsT0FBTyxpQkFBTyxDQUFDLEdBQUcsQ0FBQyxJQUFXLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQsZ0JBQXlCLENBQUM7Q0FDM0I7QUFORCxrQ0FNQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExvZ2dpbmcgfSBmcm9tIFwiLi9sb2dnaW5nXCI7XG5pbXBvcnQgeyBMb2dnZXIgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgTG9nZ2VkQ2xhc3Mge1xuICBwcm90ZWN0ZWQgZ2V0IGxvZygpOiBMb2dnZXIge1xuICAgIHJldHVybiBMb2dnaW5nLmZvcih0aGlzIGFzIGFueSk7XG4gIH1cblxuICBwcm90ZWN0ZWQgY29uc3RydWN0b3IoKSB7fVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/lib/LoggedClass.d.ts

@@ -1,5 +1,43 @@
 import { Logger } from "./types";
+/**
+ * @description Base class that provides a ready-to-use logger instance
+ * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
+ * into derived classes through a protected getter. Subclasses can directly access
+ * this.log to emit messages without manually creating a logger. This promotes
+ * consistent, context-aware logging across the codebase.
+ * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+ * @class LoggedClass
+ * @example
+ * class UserService extends LoggedClass {
+ *   create(user: User) {
+ *     this.log.info(`Creating user ${user.id}`);
+ *   }
+ * }
+ *
+ * const svc = new UserService();
+ * svc.create({ id: "42" });
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Instance as Subclass Instance
+ *   participant Getter as LoggedClass.log
+ *   participant Logging as Logging
+ *   participant Logger as Logger
+ *
+ *   Client->>Instance: call someMethod()
+ *   Instance->>Getter: access this.log
+ *   Getter->>Logging: Logging.for(this)
+ *   Logging-->>Getter: return Logger
+ *   Getter-->>Instance: return Logger
+ *   Instance->>Logger: info/debug/error(...)
+ */
 export declare abstract class LoggedClass {
+    /**
+     * @description Lazily provides a context-aware logger for the current instance
+     * @summary Uses Logging.for(this) to create a logger whose context is the
+     * subclass name, allowing uniform and structured logs from any inheriting class.
+     * @return {Logger} A logger bound to the subclass context
+     */
     protected get log(): Logger;
     protected constructor();
 }

package/lib/constants.cjs

@@ -5,6 +5,7 @@ exports.DefaultLoggingConfig = exports.DefaultTheme = exports.LoggingMode = expo
  * @description Enum for log levels.
  * @summary Defines different levels of logging for the application.
  * @enum {string}
+ * @readonly
  * @memberOf module:Logging
  */
 var LogLevel;
@@ -96,10 +97,17 @@ exports.DefaultTheme = {
             fg: 31,
             style: ["bold"],
         },
-        info: {},
-        verbose: {},
+        info: {
+            fg: 34,
+            style: ["bold"],
+        },
+        verbose: {
+            fg: 34,
+            style: ["bold"],
+        },
         debug: {
             fg: 33,
+            style: ["bold"],
         },
     },
 };
@@ -131,6 +139,8 @@ exports.DefaultLoggingConfig = {
     timestamp: true,
     timestampFormat: "HH:mm:ss.SSS",
     context: true,
+    format: "raw",
+    pattern: "{level} [{timestamp}] {context} - {message} {stack}",
     theme: exports.DefaultTheme,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAEA;;;;;GAKG;AACH,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,wBAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;GAKG;AACH,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4CAA4C;IAC5C,0BAAW,CAAA;IACX,sCAAsC;IACtC,4BAAa,CAAA;AACf,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,QAAA,YAAY,GAAU;IACjC,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE,EAAE;QACR,OAAO,EAAE,EAAE;QACX,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,oBAAoB,GAAkB;IACjD,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,IAAI,EAAE,WAAW,CAAC,GAAG;IACrB,KAAK,EAAE,KAAK;IACZ,gBAAgB,EAAE,GAAG;IACrB,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,KAAK,EAAE,oBAAY;CACpB,CAAC","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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAEA;;;;;;GAMG;AACH,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,wBAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACU,QAAA,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;GAKG;AACH,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4CAA4C;IAC5C,0BAAW,CAAA;IACX,sCAAsC;IACtC,4BAAa,CAAA;AACf,CAAC,EALW,WAAW,2BAAX,WAAW,QAKtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACU,QAAA,YAAY,GAAU;IACjC,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,OAAO,EAAE;YACP,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACU,QAAA,oBAAoB,GAAkB;IACjD,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,IAAI,EAAE,WAAW,CAAC,GAAG;IACrB,KAAK,EAAE,KAAK;IACZ,gBAAgB,EAAE,GAAG;IACrB,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,qDAAqD;IAC9D,KAAK,EAAE,oBAAY;CACpB,CAAC","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 * @readonly\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      fg: 34,\n      style: [\"bold\"],\n    },\n    verbose: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    debug: {\n      fg: 33,\n      style: [\"bold\"],\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  format: \"raw\",\n  pattern: \"{level} [{timestamp}] {context} - {message} {stack}\",\n  theme: DefaultTheme,\n};\n"]}

package/lib/constants.d.ts

@@ -3,6 +3,7 @@ import { LoggingConfig, Theme } from "./types";
  * @description Enum for log levels.
  * @summary Defines different levels of logging for the application.
  * @enum {string}
+ * @readonly
  * @memberOf module:Logging
  */
 export declare enum LogLevel {

package/lib/decorators.cjs

@@ -15,7 +15,6 @@ const logging_1 = require("./logging.cjs");
  * @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
@@ -37,13 +36,16 @@ const logging_1 = require("./logging.cjs");
  *     Decorator->>Logger: log benchmark (if enabled)
  *     Decorator-->>Client: return result
  *   end
+ * @category Method Decorators
  */
 function log(level = constants_1.LogLevel.info, benchmark = false, verbosity = 0) {
     return function (target, propertyKey, descriptor) {
+        if (!descriptor)
+            throw new Error(`Logging decoration only applies to methods`);
         const log = logging_1.Logging.for(target).for(target[propertyKey]);
         const method = log[level].bind(log);
         const originalMethod = descriptor.value;
-        descriptor.value = function (...args) {
+        const func = function (...args) {
             method(`called with ${args}`, verbosity);
             const start = Date.now();
             let end;
@@ -64,7 +66,11 @@ function log(level = constants_1.LogLevel.info, benchmark = false, verbosity = 0
                     method(`completed in ${end - start}ms`, verbosity);
             }
             return result;
-        };
+        }.bind(target);
+        Object.assign(func, "name", {
+            value: descriptor.value.name,
+        });
+        descriptor.value = func;
     };
 }
 /**
@@ -73,7 +79,7 @@ function log(level = constants_1.LogLevel.info, benchmark = false, verbosity = 0
  * @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
+ * @category Method Decorators
  */
 function debug(benchmark = false) {
     return log(constants_1.LogLevel.debug, benchmark);
@@ -84,7 +90,7 @@ function debug(benchmark = false) {
  * @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
+ * @category Method Decorators
  */
 function info(benchmark = false) {
     return log(constants_1.LogLevel.info, benchmark);
@@ -95,7 +101,7 @@ function info(benchmark = false) {
  * @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
+ * @category Method Decorators
  */
 function silly(benchmark = false) {
     return log(constants_1.LogLevel.silly, benchmark);
@@ -107,9 +113,13 @@ function silly(benchmark = false) {
  * @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
+ * @category Method Decorators
  */
-function verbose(verbosity = 0, benchmark = false) {
+function verbose(verbosity = 0, benchmark) {
+    if (typeof verbosity === "boolean") {
+        benchmark = verbosity;
+        verbosity = 0;
+    }
     return log(constants_1.LogLevel.verbose, benchmark, verbosity);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":";;AAkCA,kBAmCC;AAUD,sBAEC;AAUD,oBAEC;AAUD,sBAEC;AAWD,0BAEC;AAtHD,+CAAuC;AACvC,2CAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,GAAG,CACjB,QAAkB,oBAAQ,CAAC,IAAI,EAC/B,YAAqB,KAAK,EAC1B,SAAS,GAAG,CAAC;IAEb,OAAO,UACL,MAAW,EACX,WAAmB,EACnB,UAA8B;QAE9B,MAAM,GAAG,GAAG,iBAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;QACzD,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpC,MAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;QACxC,UAAU,CAAC,KAAK,GAAG,UAAU,GAAG,IAAW;YACzC,MAAM,CAAC,eAAe,IAAI,EAAE,EAAE,SAAS,CAAC,CAAC;YACzC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACzB,IAAI,GAAW,CAAC;YAChB,MAAM,MAAM,GAAQ,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACrD,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;gBAC9B,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBACvB,IAAI,SAAS,EAAE,CAAC;wBACd,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;wBACjB,IAAI,SAAS;4BAAE,MAAM,CAAC,gBAAgB,GAAG,GAAG,KAAK,IAAI,EAAE,SAAS,CAAC,CAAC;oBACpE,CAAC;oBACD,OAAO,CAAC,CAAC;gBACX,CAAC,CAAC,CAAC;YACL,CAAC;YACD,IAAI,SAAS,EAAE,CAAC;gBACd,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBACjB,IAAI,SAAS;oBAAE,MAAM,CAAC,gBAAgB,GAAG,GAAG,KAAK,IAAI,EAAE,SAAS,CAAC,CAAC;YACpE,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAC,YAAqB,KAAK;IAC9C,OAAO,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,IAAI,CAAC,YAAqB,KAAK;IAC7C,OAAO,GAAG,CAAC,oBAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAC,YAAqB,KAAK;IAC9C,OAAO,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,OAAO,CAAC,SAAS,GAAG,CAAC,EAAE,YAAqB,KAAK;IAC/D,OAAO,GAAG,CAAC,oBAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AACrD,CAAC","sourcesContent":["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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":";;AAkCA,kBA4CC;AAUD,sBAEC;AAUD,oBAEC;AAUD,sBAEC;AA6CD,0BAMC;AArKD,+CAAuC;AACvC,2CAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,SAAgB,GAAG,CACjB,QAAkB,oBAAQ,CAAC,IAAI,EAC/B,YAAqB,KAAK,EAC1B,SAAS,GAAG,CAAC;IAEb,OAAO,UACL,MAAW,EACX,WAAiB,EACjB,UAA+B;QAE/B,IAAI,CAAC,UAAU;YACb,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,MAAM,GAAG,GAAG,iBAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;QACzD,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpC,MAAM,cAAc,GAAG,UAAU,CAAC,KAAK,CAAC;QAExC,MAAM,IAAI,GAAG,UAA+B,GAAG,IAAW;YACxD,MAAM,CAAC,eAAe,IAAI,EAAE,EAAE,SAAS,CAAC,CAAC;YACzC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACzB,IAAI,GAAW,CAAC;YAChB,MAAM,MAAM,GAAQ,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACrD,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;gBAC9B,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;oBACvB,IAAI,SAAS,EAAE,CAAC;wBACd,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;wBACjB,IAAI,SAAS;4BAAE,MAAM,CAAC,gBAAgB,GAAG,GAAG,KAAK,IAAI,EAAE,SAAS,CAAC,CAAC;oBACpE,CAAC;oBACD,OAAO,CAAC,CAAC;gBACX,CAAC,CAAC,CAAC;YACL,CAAC;YACD,IAAI,SAAS,EAAE,CAAC;gBACd,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBACjB,IAAI,SAAS;oBAAE,MAAM,CAAC,gBAAgB,GAAG,GAAG,KAAK,IAAI,EAAE,SAAS,CAAC,CAAC;YACpE,CAAC;YAED,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,IAAI,CAAC,MAAM,CAAQ,CAAC;QAEtB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE;YAC1B,KAAK,EAAE,UAAU,CAAC,KAAK,CAAC,IAAI;SAC7B,CAAC,CAAC;QAEH,UAAU,CAAC,KAAK,GAAG,IAAI,CAAC;IAC1B,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAC,YAAqB,KAAK;IAC9C,OAAO,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,IAAI,CAAC,YAAqB,KAAK;IAC7C,OAAO,GAAG,CAAC,oBAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;AACvC,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,KAAK,CAAC,YAAqB,KAAK;IAC9C,OAAO,GAAG,CAAC,oBAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AACxC,CAAC;AAoCD;;;;;;;;GAQG;AACH,SAAgB,OAAO,CAAC,YAA8B,CAAC,EAAE,SAAmB;IAC1E,IAAI,OAAO,SAAS,KAAK,SAAS,EAAE,CAAC;QACnC,SAAS,GAAG,SAAS,CAAC;QACtB,SAAS,GAAG,CAAC,CAAC;IAChB,CAAC;IACD,OAAO,GAAG,CAAC,oBAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AACrD,CAAC","sourcesContent":["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 * @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 * @category Method Decorators\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?: any,\n    descriptor?: PropertyDescriptor\n  ) {\n    if (!descriptor)\n      throw new Error(`Logging decoration only applies to methods`);\n    const log = Logging.for(target).for(target[propertyKey]);\n    const method = log[level].bind(log);\n    const originalMethod = descriptor.value;\n\n    const func = function (this: typeof target, ...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    }.bind(target) as any;\n\n    Object.assign(func, \"name\", {\n      value: descriptor.value.name,\n    });\n\n    descriptor.value = func;\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 Method 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 Method 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 Method 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 * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(): (\n  target: any,\n  propertyKey?: any,\n  descriptor?: any\n) => void;\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 {boolean} benchmark - Whether to log execution time\n * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n */\nexport function verbose(\n  benchmark: boolean\n): (target: any, propertyKey?: any, descriptor?: any) => void;\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 * @return {Function} A method decorator that wraps the original method with verbose logging\n * @function verbose\n * @category Method Decorators\n */\nexport function verbose(\n  verbosity: number | boolean\n): (target: any, propertyKey?: any, descriptor?: any) => void;\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 Method Decorators\n */\nexport function verbose(verbosity: number | boolean = 0, benchmark?: boolean) {\n  if (typeof verbosity === \"boolean\") {\n    benchmark = verbosity;\n    verbosity = 0;\n  }\n  return log(LogLevel.verbose, benchmark, verbosity);\n}\n"]}

package/lib/decorators.d.ts

@@ -7,7 +7,6 @@ import { LogLevel } from "./constants";
  * @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
@@ -29,42 +28,57 @@ import { LogLevel } from "./constants";
  *     Decorator->>Logger: log benchmark (if enabled)
  *     Decorator-->>Client: return result
  *   end
+ * @category Method Decorators
  */
-export declare function log(level?: LogLevel, benchmark?: boolean, verbosity?: number): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function log(level?: LogLevel, benchmark?: boolean, verbosity?: number): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
 /**
  * @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
+ * @category Method Decorators
  */
-export declare function debug(benchmark?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function debug(benchmark?: boolean): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
 /**
  * @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
+ * @category Method Decorators
  */
-export declare function info(benchmark?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function info(benchmark?: boolean): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
 /**
  * @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
+ * @category Method Decorators
  */
-export declare function silly(benchmark?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function silly(benchmark?: boolean): (target: any, propertyKey?: any, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Method decorator for logging function calls with verbose level
+ * @summary Convenience wrapper around the log decorator that uses LogLevel.verbose with configurable verbosity
+ * @return {Function} A method decorator that wraps the original method with verbose logging
+ * @function verbose
+ */
+export declare function verbose(): (target: any, propertyKey?: any, descriptor?: any) => void;
+/**
+ * @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 {boolean} benchmark - Whether to log execution time
+ * @return {Function} A method decorator that wraps the original method with verbose logging
+ * @function verbose
+ */
+export declare function verbose(benchmark: boolean): (target: any, propertyKey?: any, descriptor?: any) => void;
 /**
  * @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
+ * @category Method Decorators
  */
-export declare function verbose(verbosity?: number, benchmark?: boolean): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function verbose(verbosity: number | boolean): (target: any, propertyKey?: any, descriptor?: any) => void;

package/lib/esm/LoggedClass.d.ts

@@ -1,5 +1,43 @@
 import { Logger } from "./types";
+/**
+ * @description Base class that provides a ready-to-use logger instance
+ * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
+ * into derived classes through a protected getter. Subclasses can directly access
+ * this.log to emit messages without manually creating a logger. This promotes
+ * consistent, context-aware logging across the codebase.
+ * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+ * @class LoggedClass
+ * @example
+ * class UserService extends LoggedClass {
+ *   create(user: User) {
+ *     this.log.info(`Creating user ${user.id}`);
+ *   }
+ * }
+ *
+ * const svc = new UserService();
+ * svc.create({ id: "42" });
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Instance as Subclass Instance
+ *   participant Getter as LoggedClass.log
+ *   participant Logging as Logging
+ *   participant Logger as Logger
+ *
+ *   Client->>Instance: call someMethod()
+ *   Instance->>Getter: access this.log
+ *   Getter->>Logging: Logging.for(this)
+ *   Logging-->>Getter: return Logger
+ *   Getter-->>Instance: return Logger
+ *   Instance->>Logger: info/debug/error(...)
+ */
 export declare abstract class LoggedClass {
+    /**
+     * @description Lazily provides a context-aware logger for the current instance
+     * @summary Uses Logging.for(this) to create a logger whose context is the
+     * subclass name, allowing uniform and structured logs from any inheriting class.
+     * @return {Logger} A logger bound to the subclass context
+     */
     protected get log(): Logger;
     protected constructor();
 }

package/lib/esm/LoggedClass.js

@@ -1,8 +1,46 @@
 import { Logging } from "./logging.js";
+/**
+ * @description Base class that provides a ready-to-use logger instance
+ * @summary LoggedClass is a convenience abstract class that injects a type-safe logger
+ * into derived classes through a protected getter. Subclasses can directly access
+ * this.log to emit messages without manually creating a logger. This promotes
+ * consistent, context-aware logging across the codebase.
+ * @param {void} [constructor] - No constructor arguments; subclasses may define their own
+ * @class LoggedClass
+ * @example
+ * class UserService extends LoggedClass {
+ *   create(user: User) {
+ *     this.log.info(`Creating user ${user.id}`);
+ *   }
+ * }
+ *
+ * const svc = new UserService();
+ * svc.create({ id: "42" });
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Instance as Subclass Instance
+ *   participant Getter as LoggedClass.log
+ *   participant Logging as Logging
+ *   participant Logger as Logger
+ *
+ *   Client->>Instance: call someMethod()
+ *   Instance->>Getter: access this.log
+ *   Getter->>Logging: Logging.for(this)
+ *   Logging-->>Getter: return Logger
+ *   Getter-->>Instance: return Logger
+ *   Instance->>Logger: info/debug/error(...)
+ */
 export class LoggedClass {
+    /**
+     * @description Lazily provides a context-aware logger for the current instance
+     * @summary Uses Logging.for(this) to create a logger whose context is the
+     * subclass name, allowing uniform and structured logs from any inheriting class.
+     * @return {Logger} A logger bound to the subclass context
+     */
     get log() {
         return Logging.for(this);
     }
     constructor() { }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9nZ2VkQ2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvTG9nZ2VkQ2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE9BQU8sRUFBRSxxQkFBa0I7QUFHcEMsTUFBTSxPQUFnQixXQUFXO0lBQy9CLElBQWMsR0FBRztRQUNmLE9BQU8sT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFXLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQsZ0JBQXlCLENBQUM7Q0FDM0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMb2dnaW5nIH0gZnJvbSBcIi4vbG9nZ2luZ1wiO1xuaW1wb3J0IHsgTG9nZ2VyIH0gZnJvbSBcIi4vdHlwZXNcIjtcblxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIExvZ2dlZENsYXNzIHtcbiAgcHJvdGVjdGVkIGdldCBsb2coKTogTG9nZ2VyIHtcbiAgICByZXR1cm4gTG9nZ2luZy5mb3IodGhpcyBhcyBhbnkpO1xuICB9XG5cbiAgcHJvdGVjdGVkIGNvbnN0cnVjdG9yKCkge31cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/constants.d.ts

@@ -3,6 +3,7 @@ import { LoggingConfig, Theme } from "./types";
  * @description Enum for log levels.
  * @summary Defines different levels of logging for the application.
  * @enum {string}
+ * @readonly
  * @memberOf module:Logging
  */
 export declare enum LogLevel {

package/lib/esm/constants.js

@@ -2,6 +2,7 @@
  * @description Enum for log levels.
  * @summary Defines different levels of logging for the application.
  * @enum {string}
+ * @readonly
  * @memberOf module:Logging
  */
 export var LogLevel;
@@ -93,10 +94,17 @@ export const DefaultTheme = {
             fg: 31,
             style: ["bold"],
         },
-        info: {},
-        verbose: {},
+        info: {
+            fg: 34,
+            style: ["bold"],
+        },
+        verbose: {
+            fg: 34,
+            style: ["bold"],
+        },
         debug: {
             fg: 33,
+            style: ["bold"],
         },
     },
 };
@@ -128,6 +136,8 @@ export const DefaultLoggingConfig = {
     timestamp: true,
     timestampFormat: "HH:mm:ss.SSS",
     context: true,
+    format: "raw",
+    pattern: "{level} [{timestamp}] {context} - {message} {stack}",
     theme: DefaultTheme,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,CAAN,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,KAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4CAA4C;IAC5C,0BAAW,CAAA;IACX,sCAAsC;IACtC,4BAAa,CAAA;AACf,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAU;IACjC,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE,EAAE;QACR,OAAO,EAAE,EAAE;QACX,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAkB;IACjD,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,IAAI,EAAE,WAAW,CAAC,GAAG;IACrB,KAAK,EAAE,KAAK;IACZ,gBAAgB,EAAE,GAAG;IACrB,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,KAAK,EAAE,YAAY;CACpB,CAAC","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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,QAWX;AAXD,WAAY,QAAQ;IAClB,sDAAsD;IACtD,2BAAe,CAAA;IACf,kEAAkE;IAClE,yBAAa,CAAA;IACb,uCAAuC;IACvC,+BAAmB,CAAA;IACnB,kCAAkC;IAClC,2BAAe,CAAA;IACf,4CAA4C;IAC5C,2BAAe,CAAA;AACjB,CAAC,EAXW,QAAQ,KAAR,QAAQ,QAWnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,CAAC;IACR,KAAK,EAAE,CAAC;CACT,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAN,IAAY,WAKX;AALD,WAAY,WAAW;IACrB,4CAA4C;IAC5C,0BAAW,CAAA;IACX,sCAAsC;IACtC,4BAAa,CAAA;AACf,CAAC,EALW,WAAW,KAAX,WAAW,QAKtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAU;IACjC,KAAK,EAAE;QACL,EAAE,EAAE,EAAE;KACP;IACD,EAAE,EAAE;QACF,EAAE,EAAE,EAAE;KACP;IACD,KAAK,EAAE,EAAE;IACT,SAAS,EAAE,EAAE;IACb,OAAO,EAAE;QACP,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;SACP;KACF;IACD,MAAM,EAAE,EAAE;IACV,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,IAAI,EAAE;YACJ,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,OAAO,EAAE;YACP,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;QACD,KAAK,EAAE;YACL,EAAE,EAAE,EAAE;YACN,KAAK,EAAE,CAAC,MAAM,CAAC;SAChB;KACF;CACF,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAkB;IACjD,OAAO,EAAE,CAAC;IACV,KAAK,EAAE,QAAQ,CAAC,IAAI;IACpB,QAAQ,EAAE,IAAI;IACd,IAAI,EAAE,WAAW,CAAC,GAAG;IACrB,KAAK,EAAE,KAAK;IACZ,gBAAgB,EAAE,GAAG;IACrB,SAAS,EAAE,KAAK;IAChB,SAAS,EAAE,IAAI;IACf,eAAe,EAAE,cAAc;IAC/B,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,KAAK;IACb,OAAO,EAAE,qDAAqD;IAC9D,KAAK,EAAE,YAAY;CACpB,CAAC","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 * @readonly\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      fg: 34,\n      style: [\"bold\"],\n    },\n    verbose: {\n      fg: 34,\n      style: [\"bold\"],\n    },\n    debug: {\n      fg: 33,\n      style: [\"bold\"],\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  format: \"raw\",\n  pattern: \"{level} [{timestamp}] {context} - {message} {stack}\",\n  theme: DefaultTheme,\n};\n"]}