@decaf-ts/logging 0.2.3 → 0.3.0

package/lib/logging.d.ts

@@ -2,121 +2,207 @@ import { LoggerFactory, LoggingConfig, LoggingContext, StringLike, Theme, Logger
 import { LogLevel } from "./constants";
 /**
  * @description A minimal logger implementation.
- * @summary MiniLogger is a lightweight logging class that implements the VerbosityLogger interface.
- * It provides basic logging functionality with support for different log levels and verbosity.
+ * @summary MiniLogger is a lightweight logging class that implements the Logger interface.
+ * It provides basic logging functionality with support for different log levels, verbosity,
+ * context-aware logging, and customizable formatting.
+ * @param {string} context - The context (typically class name) this logger is associated with
+ * @param {Partial<LoggingConfig>} conf - Optional configuration to override global settings
+ * @class MiniLogger
+ * @example
+ * // Create a new logger for a class
+ * const logger = new MiniLogger('MyClass');
  *
- * @class
+ * // Log messages at different levels
+ * logger.info('This is an info message');
+ * logger.debug('This is a debug message');
+ * logger.error('Something went wrong');
+ *
+ * // Create a child logger for a specific method
+ * const methodLogger = logger.for('myMethod');
+ * methodLogger.verbose('Detailed information', 2);
+ *
+ * // Log with custom configuration
+ * logger.for('specialMethod', { style: true }).info('Styled message');
  */
 export declare class MiniLogger implements Logger {
     protected context: string;
     protected conf?: Partial<LoggingConfig> | undefined;
-    /**
-     * @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: string, conf?: Partial<LoggingConfig> | undefined);
     protected config(key: keyof LoggingConfig): LoggingConfig[keyof LoggingConfig];
-    for(method?: string | ((...args: any[]) => any), config?: Partial<LoggingConfig>, ...args: any[]): Logger;
     /**
-     * @description Creates a formatted log string.
-     * @summary Generates a log string with timestamp, colored log level, and message.
-     *
-     * @param level - The log level as a string.
-     * @param message
-     * @param stack
-     * @return A formatted log string.
+     * @description Creates a child logger for a specific method or context
+     * @summary Returns a new logger instance with the current context extended by the specified method name
+     * @param {string | Function} method - The method name or function to create a logger for
+     * @param {Partial<LoggingConfig>} config - Optional configuration to override settings
+     * @param {...any} args - Additional arguments to pass to the logger factory
+     * @return {Logger} A new logger instance for the specified method
+     */
+    for(method?: string | ((...args: any[]) => any), config?: Partial<LoggingConfig>): Logger;
+    /**
+     * @description Creates a formatted log string
+     * @summary Generates a log string with timestamp, colored log level, context, and message
+     * @param {LogLevel} level - The log level for this message
+     * @param {StringLike | Error} message - The message to log or an Error object
+     * @param {string} [stack] - Optional stack trace to include in the log
+     * @return {string} A formatted log string with all components
      */
     protected createLog(level: LogLevel, message: StringLike | Error, stack?: string): string;
     /**
-     * @description Logs a message with the specified log level.
+     * @description Logs a message with the specified log level
      * @summary Checks if the message should be logged based on the current log level,
-     * then uses the appropriate console method to output the log.
-     *
-     * @param level - The log level of the message.
-     * @param msg - The message to be logged.
-     * @param stack
+     * then uses the appropriate console method to output the formatted log
+     * @param {LogLevel} level - The log level of the message
+     * @param {StringLike | Error} msg - The message to be logged or an Error object
+     * @param {string} [stack] - Optional stack trace to include in the log
+     * @return {void}
      */
     protected log(level: LogLevel, msg: StringLike | Error, stack?: string): void;
     /**
-     * @description LLogs a `way too verbose` or a silly message.
-     * @summary Logs a message at the Silly level if the current verbosity allows it.
-     *
-     * @param msg - The message to be logged.
-     * @param verbosity - The verbosity level of the message (default: 0).
+     * @description Logs a message at the silly level
+     * @summary Logs a message at the silly level if the current verbosity setting allows it
+     * @param {StringLike} msg - The message to be logged
+     * @param {number} [verbosity=0] - The verbosity level of the message
+     * @return {void}
      */
     silly(msg: StringLike, verbosity?: number): void;
     /**
-     * @description Logs a verbose message.
-     * @summary Logs a message at the Verbose level if the current verbosity allows it.
-     *
-     * @param msg - The message to be logged.
-     * @param verbosity - The verbosity level of the message (default: 0).
+     * @description Logs a message at the verbose level
+     * @summary Logs a message at the verbose level if the current verbosity setting allows it
+     * @param {StringLike} msg - The message to be logged
+     * @param {number} [verbosity=0] - The verbosity level of the message
+     * @return {void}
      */
     verbose(msg: StringLike, verbosity?: number): void;
     /**
-     * @description Logs an info message.
-     * @summary Logs a message at the Info level.
-     *
-     * @param msg - The message to be logged.
+     * @description Logs a message at the info level
+     * @summary Logs a message at the info level for general application information
+     * @param {StringLike} msg - The message to be logged
+     * @return {void}
      */
     info(msg: StringLike): void;
     /**
-     * @description Logs a debug message.
-     * @summary Logs a message at the Debug level.
-     *
-     * @param msg - The message to be logged.
+     * @description Logs a message at the debug level
+     * @summary Logs a message at the debug level for detailed troubleshooting information
+     * @param {StringLike} msg - The message to be logged
+     * @return {void}
      */
     debug(msg: StringLike): void;
     /**
-     * @description Logs an error message.
-     * @summary Logs a message at the Error level.
-     *
-     * @param msg - The message to be logged.
+     * @description Logs a message at the error level
+     * @summary Logs a message at the error level for errors and exceptions
+     * @param {StringLike | Error} msg - The message to be logged or an Error object
+     * @return {void}
      */
     error(msg: StringLike | Error): void;
+    /**
+     * @description Updates the logger configuration
+     * @summary Merges the provided configuration with the existing configuration
+     * @param {Partial<LoggingConfig>} config - The configuration options to apply
+     * @return {void}
+     */
     setConfig(config: Partial<LoggingConfig>): void;
 }
 /**
- * @description A static class for managing logging operations.
+ * @description A static class for managing logging operations
  * @summary The Logging class provides a centralized logging mechanism with support for
- * different log levels and verbosity. It uses a singleton pattern to maintain a global
+ * different log levels, verbosity, and styling. It uses a singleton pattern to maintain a global
  * logger instance and allows creating specific loggers for different classes and methods.
+ * @class Logging
+ * @example
+ * // Set global configuration
+ * Logging.setConfig({ level: LogLevel.debug, style: true });
+ *
+ * // Get a logger for a specific class
+ * const logger = Logging.for('MyClass');
+ *
+ * // Log messages at different levels
+ * logger.info('Application started');
+ * logger.debug('Processing data...');
+ *
+ * // Log with context
+ * const methodLogger = Logging.for('MyClass.myMethod');
+ * methodLogger.verbose('Detailed operation information', 1);
+ *
+ * // Log errors
+ * try {
+ *   // some operation
+ * } catch (error) {
+ *   logger.error(error);
+ * }
+ * @mermaid
+ * classDiagram
+ *   class Logger {
+ *     <<interface>>
+ *     +for(method, config, ...args)
+ *     +silly(msg, verbosity)
+ *     +verbose(msg, verbosity)
+ *     +info(msg)
+ *     +debug(msg)
+ *     +error(msg)
+ *     +setConfig(config)
+ *   }
+ *
+ *   class Logging {
+ *     -global: Logger
+ *     -_factory: LoggerFactory
+ *     -_config: LoggingConfig
+ *     +setFactory(factory)
+ *     +setConfig(config)
+ *     +getConfig()
+ *     +get()
+ *     +verbose(msg, verbosity)
+ *     +info(msg)
+ *     +debug(msg)
+ *     +silly(msg)
+ *     +error(msg)
+ *     +for(object, config, ...args)
+ *     +because(reason, id)
+ *     +theme(text, type, loggerLevel, template)
+ *   }
  *
- * @class
+ *   class MiniLogger {
+ *     +constructor(context, conf?)
+ *   }
+ *
+ *   Logging ..> Logger : creates
+ *   Logging ..> MiniLogger : creates by default
  */
 export declare class Logging {
     /**
-     * @description The global logger instance.
-     * @summary A singleton instance of VerbosityLogger used for global logging.
+     * @description The global logger instance
+     * @summary A singleton instance of Logger used for global logging
      */
     private static global?;
     /**
-     * @description Factory function for creating logger instances.
-     * @summary A function that creates new VerbosityLogger instances. By default, it creates a MiniLogger.
+     * @description Factory function for creating logger instances
+     * @summary A function that creates new Logger instances. By default, it creates a MiniLogger.
      */
     private static _factory;
     /**
-     * @description Configuration for the logging system.
-     * @summary Stores the global verbosity level and log level settings.
+     * @description Configuration for the logging system
+     * @summary Stores the global logging configuration including verbosity, log level, styling, and formatting settings
      */
     private static _config;
+    private constructor();
     /**
-     * @description Private constructor to prevent instantiation.
-     * @summary Ensures that the Logging class cannot be instantiated as it's designed to be used statically.
+     * @description Sets the factory function for creating logger instances
+     * @summary Allows customizing how logger instances are created
+     * @param {LoggerFactory} factory - The factory function to use for creating loggers
+     * @return {void}
      */
-    private constructor();
     static setFactory(factory: LoggerFactory): void;
     /**
-     * @description Setter for the logging configuration.
-     * @summary Allows updating the global logging configuration.
-     *
-     * @param config - An object containing verbosity and log level settings.
+     * @description Updates the global logging configuration
+     * @summary Allows updating the global logging configuration with new settings
+     * @param {Partial<LoggingConfig>} config - The configuration options to apply
+     * @return {void}
      */
     static setConfig(config: Partial<LoggingConfig>): void;
+    /**
+     * @description Gets a copy of the current global logging configuration
+     * @summary Returns a copy of the current global logging configuration
+     * @return {LoggingConfig} A copy of the current configuration
+     */
     static getConfig(): LoggingConfig;
     /**
      * @description Retrieves or creates the global logger instance.
@@ -161,6 +247,14 @@ export declare class Logging {
      * @param msg - The message to be logged.
      */
     static error(msg: StringLike): void;
+    /**
+     * @description Creates a logger for a specific object or context
+     * @summary Creates a new logger instance for the given object or context using the factory function
+     * @param {LoggingContext} object - The object, class, or context to create a logger for
+     * @param {Partial<LoggingConfig>} [config] - Optional configuration to override global settings
+     * @param {...any} args - Additional arguments to pass to the logger factory
+     * @return {Logger} A new logger instance for the specified object or context
+     */
     static for(object: LoggingContext, config?: Partial<LoggingConfig>, ...args: any[]): Logger;
     /**
      * @description Creates a logger for a specific reason or context.
@@ -173,5 +267,38 @@ export declare class Logging {
      * @returns A new VerbosityLogger or ClassLogger instance.
      */
     static because(reason: string, id?: string): Logger;
+    /**
+     * @description Applies theme styling to text
+     * @summary Applies styling (colors, formatting) to text based on the theme configuration
+     * @param {string} text - The text to style
+     * @param {string} type - The type of element to style (e.g., "class", "message", "logLevel")
+     * @param {LogLevel} loggerLevel - The log level to use for styling
+     * @param {Theme} [template=DefaultTheme] - The theme to use for styling
+     * @return {string} The styled text
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant Theme as Logging.theme
+     *   participant Apply as apply function
+     *   participant Style as styled-string-builder
+     *
+     *   Caller->>Theme: theme(text, type, loggerLevel)
+     *   Theme->>Theme: Check if styling is enabled
+     *   alt styling disabled
+     *     Theme-->>Caller: return original text
+     *   else styling enabled
+     *     Theme->>Theme: Get theme for type
+     *     alt theme not found
+     *       Theme-->>Caller: return original text
+     *     else theme found
+     *       Theme->>Theme: Determine actual theme based on log level
+     *       Theme->>Apply: Apply each style property
+     *       Apply->>Style: Apply colors and formatting
+     *       Style-->>Apply: Return styled text
+     *       Apply-->>Theme: Return styled text
+     *       Theme-->>Caller: Return final styled text
+     *     end
+     *   end
+     */
     static theme(text: string, type: keyof Theme | keyof LogLevel, loggerLevel: LogLevel, template?: Theme): string;
 }

package/lib/types.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["import { styles } from \"styled-string-builder\";\nimport { LoggingMode, LogLevel } from \"./constants\";\n\n/**\n * @description A type representing string-like values\n * @summary Represents either a string or an object with a toString method that returns a string\n * @typedef {(string|Object)} StringLike\n * @memberOf module:Logging\n */\nexport type StringLike = string | { toString: () => string };\n\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description A type representing logging context\n * @summary Represents a context for logging, which can be a string, a class constructor, or a function\n * @typedef {(string|Function|Object)} LoggingContext\n * @memberOf module:Logging\n */\nexport type LoggingContext =\n  | string\n  | { new (...args: any[]): any }\n  | AnyFunction;\n\n/**\n * @description Interface for a logger with verbosity levels.\n * @summary Defines methods for logging at different verbosity levels.\n * @interface Logger\n * @memberOf module:Logging\n */\nexport interface Logger {\n  /**\n   * @description Logs a `way too verbose` or a silly message.\n   * @param {StringLike} msg - The message to log.\n   */\n  silly(msg: StringLike): void;\n  /**\n   * @description Logs a verbose message.\n   * @param {StringLike} msg - The message to log.\n   * @param {number} verbosity - The verbosity level of the message.\n   */\n  verbose(msg: StringLike, verbosity?: number): void;\n\n  /**\n   * @description Logs an info message.\n   * @param {StringLike} msg - The message to log.\n   */\n  info(msg: StringLike): void;\n\n  /**\n   * @description Logs an error message.\n   * @param {StringLike | Error} msg - The message to log.\n   */\n  error(msg: StringLike | Error): void;\n\n  /**\n   * @description Logs a debug message.\n   * @param {string} msg - The message to log.\n   */\n  debug(msg: StringLike): void;\n\n  /**\n   * @description Creates a new logger for a specific method or context\n   * @summary Returns a new logger instance that includes the specified method or context in its logs\n   * @param {string|Function} [method] - The method name or function to create a logger for\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger\n   * @return {Logger} A new logger instance\n   */\n  for(\n    method?: string | ((...args: any[]) => any),\n    config?: Partial<LoggingConfig>\n  ): Logger;\n\n  /**\n   * @description Updates the logger configuration\n   * @summary Sets or updates the configuration options for this logger instance\n   * @param {Partial<LoggingConfig>} config - The configuration options to apply\n   */\n  setConfig(config: Partial<LoggingConfig>): void;\n}\n\n/**\n * @description Configuration for logging.\n * @summary Defines the log level and verbosity for logging.\n * @typedef {Object} LoggingConfig\n * @property {LogLevel} level - The logging level.\n * @property {boolean} [logLevel] - Whether to display log level in output.\n * @property {number} verbose - The verbosity level.\n * @property {LoggingMode} [mode] - Output format mode.\n * @property {string} contextSeparator - Separator between context entries.\n * @property {string} separator - Separator between log components.\n * @property {boolean} [style] - Whether to apply styling to log output.\n * @property {boolean} [timestamp] - Whether to include timestamps in log messages.\n * @property {string} [timestampFormat] - Format for timestamps.\n * @property {boolean} [context] - Whether to include context information in log messages.\n * @property {Theme} [theme] - The theme to use for styling log messages.\n * @property {string|number} [correlationId] - Correlation ID for tracking related log messages.\n * @memberOf module:Logging\n */\nexport type LoggingConfig = {\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  mode?: LoggingMode;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  correlationId?: string | number;\n};\n\n/**\n * @description A factory function type for creating loggers\n * @summary Defines a function type that creates and returns a logger instance for a given object\n * @template L - The logger type, extending the base Logger interface\n * @typedef {Function} LoggerFactory\n * @param {string} object - The object or context name for the logger\n * @param {Partial<LoggingConfig>} [config] - Optional configuration for the logger\n * @return {L} A logger instance\n * @memberOf module:Logging\n */\nexport type LoggerFactory<L extends Logger = Logger> = (\n  object: string,\n  config?: Partial<LoggingConfig>,\n  ...args: any[]\n) => L;\n\n/**\n * @description Represents a theme option for console output styling.\n * @summary Defines the structure for styling a specific element in the console output.\n * It allows for customization of foreground color, background color, and additional styles.\n * Colors can be specified as a single number, an RGB array, or left undefined for default.\n * @interface ThemeOption\n * @memberOf module:Logging\n */\nexport interface ThemeOption {\n  fg?: number | [number] | [number, number, number];\n\n  bg?: number | [number] | [number, number, number];\n\n  style?: number[] | [keyof typeof styles];\n}\n\n/**\n * @description A type for theme options organized by log level\n * @summary Defines a partial record mapping log levels to theme options, allowing different styling for different log levels\n * @typedef {Object} ThemeOptionByLogLevel\n * @memberOf module:Logging\n */\nexport type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;\n\n/**\n * @description Defines the color theme for console output.\n * @summary This interface specifies the color scheme for various elements of console output,\n * including styling for different log levels and components. It uses ThemeOption to\n * define the styling for each element, allowing for customization of colors and styles\n * for different parts of the log output.\n * @interface Theme\n * @memberOf module:Logging\n */\nexport interface Theme {\n  /**\n   * @description Styling for class names in the output.\n   */\n  class: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for timestamps in the output.\n   */\n  timestamp: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for the main message text in the output.\n   */\n  message: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for method names in the output.\n   */\n  method: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  id: ThemeOption | ThemeOptionByLogLevel;\n\n  /**\n   * @description Styling for identifier elements in the output.\n   */\n  stack: ThemeOption;\n\n  /**\n   * @description Styling for different log levels in the output.\n   */\n  logLevel: ThemeOptionByLogLevel;\n}\n"]}

package/lib/types.d.ts

@@ -1,16 +1,29 @@
 import { styles } from "styled-string-builder";
 import { LoggingMode, LogLevel } from "./constants";
+/**
+ * @description A type representing string-like values
+ * @summary Represents either a string or an object with a toString method that returns a string
+ * @typedef {(string|Object)} StringLike
+ * @memberOf module:Logging
+ */
 export type StringLike = string | {
     toString: () => string;
 };
+export type AnyFunction = (...args: any[]) => any;
+/**
+ * @description A type representing logging context
+ * @summary Represents a context for logging, which can be a string, a class constructor, or a function
+ * @typedef {(string|Function|Object)} LoggingContext
+ * @memberOf module:Logging
+ */
 export type LoggingContext = string | {
     new (...args: any[]): any;
-} | ((...args: any[]) => any);
+} | AnyFunction;
 /**
  * @description Interface for a logger with verbosity levels.
  * @summary Defines methods for logging at different verbosity levels.
  * @interface Logger
- * @memberOf @decaf-ts/utils
+ * @memberOf module:Logging
  */
 export interface Logger {
     /**
@@ -39,7 +52,19 @@ export interface Logger {
      * @param {string} msg - The message to log.
      */
     debug(msg: StringLike): void;
+    /**
+     * @description Creates a new logger for a specific method or context
+     * @summary Returns a new logger instance that includes the specified method or context in its logs
+     * @param {string|Function} [method] - The method name or function to create a logger for
+     * @param {Partial<LoggingConfig>} [config] - Optional configuration for the new logger
+     * @return {Logger} A new logger instance
+     */
     for(method?: string | ((...args: any[]) => any), config?: Partial<LoggingConfig>): Logger;
+    /**
+     * @description Updates the logger configuration
+     * @summary Sets or updates the configuration options for this logger instance
+     * @param {Partial<LoggingConfig>} config - The configuration options to apply
+     */
     setConfig(config: Partial<LoggingConfig>): void;
 }
 /**
@@ -47,14 +72,25 @@ export interface Logger {
  * @summary Defines the log level and verbosity for logging.
  * @typedef {Object} LoggingConfig
  * @property {LogLevel} level - The logging level.
+ * @property {boolean} [logLevel] - Whether to display log level in output.
  * @property {number} verbose - The verbosity level.
- * @memberOf @decaf-ts/utils
+ * @property {LoggingMode} [mode] - Output format mode.
+ * @property {string} contextSeparator - Separator between context entries.
+ * @property {string} separator - Separator between log components.
+ * @property {boolean} [style] - Whether to apply styling to log output.
+ * @property {boolean} [timestamp] - Whether to include timestamps in log messages.
+ * @property {string} [timestampFormat] - Format for timestamps.
+ * @property {boolean} [context] - Whether to include context information in log messages.
+ * @property {Theme} [theme] - The theme to use for styling log messages.
+ * @property {string|number} [correlationId] - Correlation ID for tracking related log messages.
+ * @memberOf module:Logging
  */
 export type LoggingConfig = {
     level: LogLevel;
     logLevel?: boolean;
     verbose: number;
     mode?: LoggingMode;
+    contextSeparator: string;
     separator: string;
     style?: boolean;
     timestamp?: boolean;
@@ -63,33 +99,45 @@ export type LoggingConfig = {
     theme?: Theme;
     correlationId?: string | number;
 };
+/**
+ * @description A factory function type for creating loggers
+ * @summary Defines a function type that creates and returns a logger instance for a given object
+ * @template L - The logger type, extending the base Logger interface
+ * @typedef {Function} LoggerFactory
+ * @param {string} object - The object or context name for the logger
+ * @param {Partial<LoggingConfig>} [config] - Optional configuration for the logger
+ * @return {L} A logger instance
+ * @memberOf module:Logging
+ */
 export type LoggerFactory<L extends Logger = Logger> = (object: string, config?: Partial<LoggingConfig>, ...args: any[]) => L;
 /**
- /**
  * @description Represents a theme option for console output styling.
  * @summary Defines the structure for styling a specific element in the console output.
  * It allows for customization of foreground color, background color, and additional styles.
  * Colors can be specified as a single number, an RGB array, or left undefined for default.
- *
  * @interface ThemeOption
- * @memberOf @decaf-ts/utils
+ * @memberOf module:Logging
  */
 export interface ThemeOption {
     fg?: number | [number] | [number, number, number];
     bg?: number | [number] | [number, number, number];
     style?: number[] | [keyof typeof styles];
 }
+/**
+ * @description A type for theme options organized by log level
+ * @summary Defines a partial record mapping log levels to theme options, allowing different styling for different log levels
+ * @typedef {Object} ThemeOptionByLogLevel
+ * @memberOf module:Logging
+ */
 export type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;
 /**
- /**
  * @description Defines the color theme for console output.
  * @summary This interface specifies the color scheme for various elements of console output,
  * including styling for different log levels and components. It uses ThemeOption to
  * define the styling for each element, allowing for customization of colors and styles
  * for different parts of the log output.
- *
  * @interface Theme
- * @memberOf @decaf-ts/utils
+ * @memberOf module:Logging
  */
 export interface Theme {
     /**

package/lib/winston/winston.cjs

@@ -6,6 +6,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WinstonFactory = exports.WinstonLogger = void 0;
 const winston_1 = __importDefault(require("winston"));
 const logging_1 = require("./../logging.cjs");
+/**
+ * @description A logger implementation using Winston
+ * @summary WinstonLogger extends MiniLogger to provide logging functionality using the Winston library.
+ * It configures Winston with appropriate transports and formats based on the logging configuration.
+ * @param {string} cont - The context (typically class name) this logger is associated with
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings
+ * @param {Transport[]|Transport} [transports] - Winston transports to use for logging
+ * @class WinstonLogger
+ * @example
+ * // Create a Winston logger for a class
+ * const logger = new WinstonLogger('MyClass');
+ *
+ * // Log messages at different levels
+ * logger.info('Application started');
+ * logger.error(new Error('Something went wrong'));
+ *
+ * // Create a child logger for a specific method
+ * const methodLogger = logger.for('myMethod');
+ * methodLogger.debug('Processing data...');
+ */
 class WinstonLogger extends logging_1.MiniLogger {
     constructor(cont, conf, transports) {
         super(cont, conf);
@@ -36,6 +56,14 @@ class WinstonLogger extends logging_1.MiniLogger {
         };
         this.winston = winston_1.default.createLogger(winstonConfig);
     }
+    /**
+     * @description Logs a message with the specified log level using Winston
+     * @summary Overrides the base log method to use Winston for logging
+     * @param {LogLevel} level - The log level of the message
+     * @param {StringLike | Error} msg - The message to be logged or an Error object
+     * @param {string} [stack] - Optional stack trace to include in the log
+     * @return {void}
+     */
     log(level, msg, stack) {
         const logData = {
             level: level,
@@ -47,6 +75,17 @@ class WinstonLogger extends logging_1.MiniLogger {
     }
 }
 exports.WinstonLogger = WinstonLogger;
+/**
+ * @description Factory function for creating Winston loggers
+ * @summary A LoggerFactory implementation that creates WinstonLogger instances
+ * @const WinstonFactory
+ * @type {LoggerFactory}
+ * @param {string} context - The context (typically class name) for the logger
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings
+ * @param {...any} args - Additional arguments to pass to the WinstonLogger constructor
+ * @return {WinstonLogger} A new WinstonLogger instance
+ * @memberOf module:Logging
+ */
 const WinstonFactory = (context, conf, ...args) => new WinstonLogger(context, conf, ...args);
 exports.WinstonFactory = WinstonFactory;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/winston/winston.d.ts

@@ -3,10 +3,49 @@ import Transport from "winston-transport";
 import { Logger, LoggerFactory, LoggingConfig, StringLike } from "../types";
 import { MiniLogger } from "../logging";
 import { LogLevel } from "../constants";
+/**
+ * @description A logger implementation using Winston
+ * @summary WinstonLogger extends MiniLogger to provide logging functionality using the Winston library.
+ * It configures Winston with appropriate transports and formats based on the logging configuration.
+ * @param {string} cont - The context (typically class name) this logger is associated with
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings
+ * @param {Transport[]|Transport} [transports] - Winston transports to use for logging
+ * @class WinstonLogger
+ * @example
+ * // Create a Winston logger for a class
+ * const logger = new WinstonLogger('MyClass');
+ *
+ * // Log messages at different levels
+ * logger.info('Application started');
+ * logger.error(new Error('Something went wrong'));
+ *
+ * // Create a child logger for a specific method
+ * const methodLogger = logger.for('myMethod');
+ * methodLogger.debug('Processing data...');
+ */
 export declare class WinstonLogger extends MiniLogger implements Logger {
     protected transports?: (Transport[] | Transport) | undefined;
     protected winston: winston.Logger;
     constructor(cont: string, conf?: Partial<LoggingConfig>, transports?: (Transport[] | Transport) | undefined);
+    /**
+     * @description Logs a message with the specified log level using Winston
+     * @summary Overrides the base log method to use Winston for logging
+     * @param {LogLevel} level - The log level of the message
+     * @param {StringLike | Error} msg - The message to be logged or an Error object
+     * @param {string} [stack] - Optional stack trace to include in the log
+     * @return {void}
+     */
     protected log(level: LogLevel, msg: StringLike | Error, stack?: string): void;
 }
+/**
+ * @description Factory function for creating Winston loggers
+ * @summary A LoggerFactory implementation that creates WinstonLogger instances
+ * @const WinstonFactory
+ * @type {LoggerFactory}
+ * @param {string} context - The context (typically class name) for the logger
+ * @param {Partial<LoggingConfig>} [conf] - Optional configuration to override global settings
+ * @param {...any} args - Additional arguments to pass to the WinstonLogger constructor
+ * @return {WinstonLogger} A new WinstonLogger instance
+ * @memberOf module:Logging
+ */
 export declare const WinstonFactory: LoggerFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/logging",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "simple winston inspired wrapper for cross lib logging",
   "type": "module",
   "exports": {