@decaf-ts/logging 0.3.12 → 0.3.14

package/lib/time.d.ts

@@ -0,0 +1,149 @@
+/**
+ * @description Snapshot of a recorded lap interval.
+ * @summary Captures the lap index, optional label, elapsed milliseconds for the lap, and cumulative elapsed time since the stopwatch started.
+ * @typedef {Object} Lap
+ * @property {number} index - Zero-based lap order.
+ * @property {string} [label] - Optional label describing the lap.
+ * @property {number} ms - Duration of the lap in milliseconds.
+ * @property {number} totalMs - Total elapsed time when the lap was recorded.
+ * @memberOf module:Logging
+ */
+export type Lap = {
+    index: number;
+    label?: string;
+    /** Duration of this lap in milliseconds */
+    ms: number;
+    /** Cumulative time up to this lap in milliseconds */
+    totalMs: number;
+};
+type NowFn = () => number;
+/**
+ * @description High-resolution clock accessor returning milliseconds.
+ * @summary Chooses the most precise timer available in the current runtime, preferring `performance.now` or `process.hrtime.bigint`.
+ * @return {number} Milliseconds elapsed according to the best available clock.
+ */
+export declare const now: NowFn;
+/**
+ * @description High-resolution stopwatch with pause, resume, and lap tracking.
+ * @summary Tracks elapsed time using the highest precision timer available, supports pausing, resuming, and recording labeled laps for diagnostics and benchmarking.
+ * @param {boolean} [autoStart=false] - When true, the stopwatch starts immediately upon construction.
+ * @class StopWatch
+ * @example
+ * const sw = new StopWatch(true);
+ * // ... work ...
+ * const lap = sw.lap("phase 1");
+ * sw.pause();
+ * console.log(`Elapsed: ${lap.totalMs}ms`);
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant StopWatch
+ *   participant Clock as now()
+ *   Client->>StopWatch: start()
+ *   StopWatch->>Clock: now()
+ *   Clock-->>StopWatch: timestamp
+ *   Client->>StopWatch: lap()
+ *   StopWatch->>Clock: now()
+ *   Clock-->>StopWatch: timestamp
+ *   StopWatch-->>Client: Lap
+ *   Client->>StopWatch: pause()
+ *   StopWatch->>Clock: now()
+ *   Clock-->>StopWatch: timestamp
+ */
+export declare class StopWatch {
+    private _startMs;
+    private _elapsedMs;
+    private _running;
+    private _laps;
+    private _lastLapTotalMs;
+    constructor(autoStart?: boolean);
+    /**
+     * @description Indicates whether the stopwatch is actively running.
+     * @summary Returns `true` when timing is in progress and `false` when paused or stopped.
+     * @return {boolean} Current running state.
+     */
+    get running(): boolean;
+    /**
+     * @description Elapsed time captured by the stopwatch.
+     * @summary Computes the total elapsed time in milliseconds, including the current session if running.
+     * @return {number} Milliseconds elapsed since the stopwatch started.
+     */
+    get elapsedMs(): number;
+    /**
+     * @description Starts timing if the stopwatch is not already running.
+     * @summary Records the current timestamp and transitions the stopwatch into the running state.
+     * @return {this} Fluent reference to the stopwatch.
+     */
+    start(): this;
+    /**
+     * @description Pauses timing and accumulates elapsed milliseconds.
+     * @summary Captures the partial duration, updates the accumulator, and keeps the stopwatch ready to resume later.
+     * @return {this} Fluent reference to the stopwatch.
+     */
+    pause(): this;
+    /**
+     * @description Resumes timing after a pause.
+     * @summary Captures a fresh start timestamp while keeping previous elapsed time intact.
+     * @return {this} Fluent reference to the stopwatch.
+     */
+    resume(): this;
+    /**
+     * @description Stops timing and returns the total elapsed milliseconds.
+     * @summary Invokes {@link StopWatch.pause} to consolidate elapsed time, leaving the stopwatch in a non-running state.
+     * @return {number} Milliseconds accumulated across all runs.
+     */
+    stop(): number;
+    /**
+     * @description Resets the stopwatch state while optionally continuing to run.
+     * @summary Clears elapsed time and lap history, preserving whether the stopwatch should continue ticking.
+     * @return {this} Fluent reference to the stopwatch.
+     */
+    reset(): this;
+    /**
+     * @description Records a lap split since the stopwatch started or since the previous lap.
+     * @summary Stores the lap metadata, updates cumulative tracking, and returns the newly created {@link Lap}.
+     * @param {string} [label] - Optional label describing the lap.
+     * @return {Lap} Lap snapshot capturing incremental and cumulative timings.
+     */
+    lap(label?: string): Lap;
+    /**
+     * @description Retrieves the recorded lap history.
+     * @summary Returns the internal lap array as a read-only view to prevent external mutation.
+     * @return {Lap[]} Laps captured by the stopwatch.
+     */
+    get laps(): readonly Lap[];
+    /**
+     * @description Formats the elapsed time in a human-readable representation.
+     * @summary Uses {@link formatMs} to produce an `hh:mm:ss.mmm` string for display and logging.
+     * @return {string} Elapsed time formatted for presentation.
+     */
+    toString(): string;
+    /**
+     * @description Serializes the stopwatch state.
+     * @summary Provides a JSON-friendly snapshot including running state, elapsed time, and lap details.
+     * @return {{running: boolean, elapsedMs: number, laps: Lap[]}} Serializable stopwatch representation.
+     */
+    toJSON(): {
+        running: boolean;
+        elapsedMs: number;
+        laps: Lap[];
+    };
+}
+/**
+ * @description Formats milliseconds into `hh:mm:ss.mmm`.
+ * @summary Breaks the duration into hours, minutes, seconds, and milliseconds, returning a zero-padded string.
+ * @param {number} ms - Milliseconds to format.
+ * @return {string} Formatted duration string.
+ * @function formatMs
+ * @memberOf module:Logging
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant Formatter as formatMs
+ *   Caller->>Formatter: formatMs(ms)
+ *   Formatter->>Formatter: derive hours/minutes/seconds
+ *   Formatter->>Formatter: pad segments
+ *   Formatter-->>Caller: hh:mm:ss.mmm
+ */
+export declare function formatMs(ms: number): string;
+export {};

package/lib/types.cjs

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# 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 * @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\n/**\n * @description A generic function type with any arguments and return\n * @summary Represents any callable signature, useful for annotating higher-order utilities\n * and dynamic method references where argument and return types are not constrained.\n * @typedef {Function} AnyFunction\n * @memberOf module:Logging\n */\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description A constructable class type\n * @summary Describes a class constructor that produces instances of type T. Useful when\n * passing class references around (e.g., for context or dependency injection).\n * @template T\n * @typedef {function(any[]): T} Class\n * @memberOf module:Logging\n */\nexport type Class<T> = {\n  new (...args: any[]): T;\n};\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 = string | Class<any> | AnyFunction;\n\nexport interface Impersonatable<THIS, ARGS extends any[] = any[]> {\n  for(...args: ARGS): THIS;\n}\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  extends Impersonatable<\n    Logger,\n    [\n      (\n        | string\n        | { new (...args: any[]): any }\n        | AnyFunction\n        | Partial<LoggingConfig>\n      ),\n      Partial<LoggingConfig>,\n      ...any[],\n    ]\n  > {\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   * @param e\n   */\n  error(msg: StringLike | Error, e?: 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   * @param args\n   * @return {Logger} A new logger instance\n   */\n  for(\n    method:\n      | string\n      | { new (...args: any[]): any }\n      | AnyFunction\n      | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\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\nexport interface LoggingFilter {\n  filter(config: LoggingConfig, message: string, context: string[]): string;\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  app?: string;\n  env: \"development\" | \"production\" | \"test\" | \"staging\" | string;\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  format: LoggingMode;\n  pattern: string;\n  correlationId?: string | number;\n  filters?: string[] | LoggingFilter[];\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  app: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for class names in the output.\n   */\n  separator: ThemeOption | ThemeOptionByLogLevel;\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"]}
+//# 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 * @description String-compatible value accepted by the logging APIs.\n * @summary Represents either a literal string or an object exposing a `toString()` method, allowing lazy stringification of complex payloads.\n * @typedef {(string|Object)} StringLike\n * @memberOf module:Logging\n */\nexport type StringLike = string | { toString: () => string };\n\n/**\n * @description Generic function signature for loosely typed callbacks.\n * @summary Covers variadic functions whose arguments and return types are not constrained, enabling the logging layer to accept any callable.\n * @typedef {function(any[]): any} AnyFunction\n * @memberOf module:Logging\n */\nexport type AnyFunction = (...args: any[]) => any;\n\n/**\n * @description Constructable class type.\n * @summary Describes a constructor that produces instances of type `T`, allowing APIs to accept class references for context-aware logging.\n * @template T\n * @typedef {any} Class\n * @memberOf module:Logging\n */\nexport type Class<T> = {\n  new (...args: any[]): T;\n};\n\n/**\n * @description Context descriptor accepted when requesting a logger instance.\n * @summary Allows the logging system to resolve context names from strings, constructors, or functions.\n * @typedef {(string|Function|Object)} LoggingContext\n * @memberOf module:Logging\n */\nexport type LoggingContext = string | Class<any> | AnyFunction;\n\n/**\n * @description Interface for factories that create contextual clones of the receiver.\n * @summary Declares a `for` method that returns another instance of `THIS` using the provided arguments, enabling chained logger customization.\n * @template THIS\n * @template ARGS\n * @interface Impersonatable\n * @memberOf module:Logging\n */\nexport interface Impersonatable<THIS, ARGS extends any[] = any[]> {\n  /**\n   * @description Produce a copy of the current instance with altered context.\n   * @summary Called by logging utilities to derive child objects with supplemental configuration and context metadata.\n   * @template THIS\n   * @template ARGS\n   * @param {ARGS} args - Arguments forwarded to the impersonation strategy.\n   * @return {THIS} Derived instance using the provided arguments.\n   */\n  for(...args: ARGS): THIS;\n}\n\n/**\n * @description Interface for loggers that support multiple verbosity levels.\n * @summary Declares severity-specific log methods, configuration overrides, and factory helpers used throughout the logging toolkit.\n * @interface Logger\n * @memberOf module:Logging\n */\nexport interface Logger\n  extends Impersonatable<\n    Logger,\n    [\n      (\n        | string\n        | { new (...args: any[]): any }\n        | AnyFunction\n        | Partial<LoggingConfig>\n      ),\n      Partial<LoggingConfig>,\n      ...any[],\n    ]\n  > {\n  /**\n   * @description Logs a benchmark message.\n   * @summary Emits high-frequency performance metrics at the `benchmark` log level.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  benchmark(msg: StringLike): void;\n\n  /**\n   * @description Logs a `way too verbose` or a silly message.\n   * @summary Emits playful or extremely verbose details at the `silly` log level.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  silly(msg: StringLike): void;\n  /**\n   * @description Logs a verbose message.\n   * @summary Writes diagnostic output governed by the configured verbosity threshold.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @param {number} [verbosity] - Verbosity level required for the message to pass through.\n   * @return {void}\n   */\n  verbose(msg: StringLike, verbosity?: number): void;\n\n  /**\n   * @description Logs an info message.\n   * @summary Emits general informational events that describe application progress.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  info(msg: StringLike): void;\n\n  /**\n   * @description Logs an error message.\n   * @summary Records errors and exceptions, including optional stack traces.\n   * @param {StringLike|Error} msg - Message or {@link Error} instance to log.\n   * @param {Error} [e] - Optional secondary error or cause.\n   * @return {void}\n   */\n  error(msg: StringLike | Error, e?: Error): void;\n\n  /**\n   * @description Logs a debug message.\n   * @summary Emits fine-grained diagnostic details useful during development and troubleshooting.\n   * @param {StringLike} msg - Message or payload to emit.\n   * @return {void}\n   */\n  debug(msg: StringLike): void;\n\n  /**\n   * @description Creates a new logger for a specific method or context.\n   * @summary Produces a scoped logger that formats entries using the derived context and overrides supplied configuration.\n   * @param {any} method - Method name, callback, constructor, or partial configuration used to seed the child logger.\n   * @param {Partial<LoggingConfig>} [config] - Optional configuration overrides for the child logger.\n   * @param {...any[]} args - Extra arguments forwarded to factory implementations.\n   * @return {Logger} Logger instance tailored to the supplied context.\n   */\n  for(\n    method:\n      | string\n      | { new (...args: any[]): any }\n      | AnyFunction\n      | Partial<LoggingConfig>,\n    config?: Partial<LoggingConfig>,\n    ...args: any[]\n  ): Logger;\n\n  /**\n   * @description Updates the logger configuration.\n   * @summary Merges the given options into the logger's existing configuration.\n   * @param {Partial<LoggingConfig>} config - Configuration overrides to apply.\n   * @return {void}\n   */\n  setConfig(config: Partial<LoggingConfig>): void;\n}\n\n/**\n * @description Interface for filters that mutate or reject log messages.\n * @summary Allows custom pre-processing of log entries before they are formatted or emitted.\n * @interface LoggingFilter\n * @memberOf module:Logging\n */\nexport interface LoggingFilter {\n  /**\n   * @description Apply filtering logic to an incoming message.\n   * @summary Receives the active configuration, original message, and context stack to produce the final message string.\n   * @param {LoggingConfig} config - Active logging configuration.\n   * @param {string} message - Message submitted for logging.\n   * @param {string[]} context - Context identifiers associated with the message.\n   * @return {string} Filtered message string.\n   */\n  filter(config: LoggingConfig, message: string, context: string[]): string;\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  app?: string;\n  env: \"development\" | \"production\" | \"test\" | \"staging\" | string;\n  level: LogLevel;\n  logLevel?: boolean;\n  verbose: number;\n  contextSeparator: string;\n  separator: string;\n  style?: boolean;\n  timestamp?: boolean;\n  timestampFormat?: string;\n  context?: boolean;\n  theme?: Theme;\n  format: LoggingMode;\n  pattern: string;\n  correlationId?: string | number;\n  filters?: string[] | LoggingFilter[];\n};\n\n/**\n * @description Factory signature for creating logger instances.\n * @summary Allows consumers to override logger construction with custom implementations.\n * @template L - The logger type, extending the base Logger interface\n * @typedef {function(string, Partial<LoggingConfig>, any[]): L} LoggerFactory\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 Theme option applied to a specific log element.\n * @summary Configures foreground and background colors as well as additional style directives for styled console output.\n * @interface ThemeOption\n * @memberOf module:Logging\n */\nexport interface ThemeOption {\n  fg?: number | [number] | [number, number, number];\n  bg?: number | [number] | [number, number, number];\n  style?: number[] | [keyof typeof styles];\n}\n\n/**\n * @description Mapping between log levels and theme overrides.\n * @summary Enables level-specific styling by associating each {@link LogLevel} with a {@link ThemeOption} configuration.\n * @typedef {Object} ThemeOptionByLogLevel\n * @memberOf module:Logging\n */\nexport type ThemeOptionByLogLevel = Partial<Record<LogLevel, ThemeOption>>;\n\n/**\n * @description Theme definition applied to console output.\n * @summary Specifies styling for each console log element and supports overrides based on {@link LogLevel} values.\n * @interface Theme\n * @memberOf module:Logging\n */\nexport interface Theme {\n  /**\n   * @description Styling for application identifiers in the output.\n   */\n  app: ThemeOption | ThemeOptionByLogLevel;\n  /**\n   * @description Styling for separators inserted between log sections.\n   */\n  separator: ThemeOption | ThemeOptionByLogLevel;\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 stack trace blocks in the output.\n   */\n  stack: ThemeOption;\n\n  /**\n   * @description Styling overrides keyed by {@link LogLevel}.\n   */\n  logLevel: ThemeOptionByLogLevel;\n}\n"]}

package/lib/types.d.ts

@@ -1,8 +1,8 @@
 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
+ * @description String-compatible value accepted by the logging APIs.
+ * @summary Represents either a literal string or an object exposing a `toString()` method, allowing lazy stringification of complex payloads.
  * @typedef {(string|Object)} StringLike
  * @memberOf module:Logging
  */
@@ -10,37 +10,51 @@ export type StringLike = string | {
     toString: () => string;
 };
 /**
- * @description A generic function type with any arguments and return
- * @summary Represents any callable signature, useful for annotating higher-order utilities
- * and dynamic method references where argument and return types are not constrained.
- * @typedef {Function} AnyFunction
+ * @description Generic function signature for loosely typed callbacks.
+ * @summary Covers variadic functions whose arguments and return types are not constrained, enabling the logging layer to accept any callable.
+ * @typedef {function(any[]): any} AnyFunction
  * @memberOf module:Logging
  */
 export type AnyFunction = (...args: any[]) => any;
 /**
- * @description A constructable class type
- * @summary Describes a class constructor that produces instances of type T. Useful when
- * passing class references around (e.g., for context or dependency injection).
+ * @description Constructable class type.
+ * @summary Describes a constructor that produces instances of type `T`, allowing APIs to accept class references for context-aware logging.
  * @template T
- * @typedef {function(any[]): T} Class
+ * @typedef {any} Class
  * @memberOf module:Logging
  */
 export type Class<T> = {
     new (...args: any[]): T;
 };
 /**
- * @description A type representing logging context
- * @summary Represents a context for logging, which can be a string, a class constructor, or a function
+ * @description Context descriptor accepted when requesting a logger instance.
+ * @summary Allows the logging system to resolve context names from strings, constructors, or functions.
  * @typedef {(string|Function|Object)} LoggingContext
  * @memberOf module:Logging
  */
 export type LoggingContext = string | Class<any> | AnyFunction;
+/**
+ * @description Interface for factories that create contextual clones of the receiver.
+ * @summary Declares a `for` method that returns another instance of `THIS` using the provided arguments, enabling chained logger customization.
+ * @template THIS
+ * @template ARGS
+ * @interface Impersonatable
+ * @memberOf module:Logging
+ */
 export interface Impersonatable<THIS, ARGS extends any[] = any[]> {
+    /**
+     * @description Produce a copy of the current instance with altered context.
+     * @summary Called by logging utilities to derive child objects with supplemental configuration and context metadata.
+     * @template THIS
+     * @template ARGS
+     * @param {ARGS} args - Arguments forwarded to the impersonation strategy.
+     * @return {THIS} Derived instance using the provided arguments.
+     */
     for(...args: ARGS): THIS;
 }
 /**
- * @description Interface for a logger with verbosity levels.
- * @summary Defines methods for logging at different verbosity levels.
+ * @description Interface for loggers that support multiple verbosity levels.
+ * @summary Declares severity-specific log methods, configuration overrides, and factory helpers used throughout the logging toolkit.
  * @interface Logger
  * @memberOf module:Logging
  */
@@ -51,52 +65,84 @@ export interface Logger extends Impersonatable<Logger, [
     Partial<LoggingConfig>,
     ...any[]
 ]> {
+    /**
+     * @description Logs a benchmark message.
+     * @summary Emits high-frequency performance metrics at the `benchmark` log level.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
+     */
+    benchmark(msg: StringLike): void;
     /**
      * @description Logs a `way too verbose` or a silly message.
-     * @param {StringLike} msg - The message to log.
+     * @summary Emits playful or extremely verbose details at the `silly` log level.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
      */
     silly(msg: StringLike): void;
     /**
      * @description Logs a verbose message.
-     * @param {StringLike} msg - The message to log.
-     * @param {number} verbosity - The verbosity level of the message.
+     * @summary Writes diagnostic output governed by the configured verbosity threshold.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @param {number} [verbosity] - Verbosity level required for the message to pass through.
+     * @return {void}
      */
     verbose(msg: StringLike, verbosity?: number): void;
     /**
      * @description Logs an info message.
-     * @param {StringLike} msg - The message to log.
+     * @summary Emits general informational events that describe application progress.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
      */
     info(msg: StringLike): void;
     /**
      * @description Logs an error message.
-     * @param {StringLike | Error} msg - The message to log.
-     * @param e
+     * @summary Records errors and exceptions, including optional stack traces.
+     * @param {StringLike|Error} msg - Message or {@link Error} instance to log.
+     * @param {Error} [e] - Optional secondary error or cause.
+     * @return {void}
      */
     error(msg: StringLike | Error, e?: Error): void;
     /**
      * @description Logs a debug message.
-     * @param {string} msg - The message to log.
+     * @summary Emits fine-grained diagnostic details useful during development and troubleshooting.
+     * @param {StringLike} msg - Message or payload to emit.
+     * @return {void}
      */
     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
-     * @param args
-     * @return {Logger} A new logger instance
+     * @description Creates a new logger for a specific method or context.
+     * @summary Produces a scoped logger that formats entries using the derived context and overrides supplied configuration.
+     * @param {any} method - Method name, callback, constructor, or partial configuration used to seed the child logger.
+     * @param {Partial<LoggingConfig>} [config] - Optional configuration overrides for the child logger.
+     * @param {...any[]} args - Extra arguments forwarded to factory implementations.
+     * @return {Logger} Logger instance tailored to the supplied context.
      */
     for(method: string | {
         new (...args: any[]): any;
     } | AnyFunction | Partial<LoggingConfig>, config?: Partial<LoggingConfig>, ...args: any[]): 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
+     * @description Updates the logger configuration.
+     * @summary Merges the given options into the logger's existing configuration.
+     * @param {Partial<LoggingConfig>} config - Configuration overrides to apply.
+     * @return {void}
      */
     setConfig(config: Partial<LoggingConfig>): void;
 }
+/**
+ * @description Interface for filters that mutate or reject log messages.
+ * @summary Allows custom pre-processing of log entries before they are formatted or emitted.
+ * @interface LoggingFilter
+ * @memberOf module:Logging
+ */
 export interface LoggingFilter {
+    /**
+     * @description Apply filtering logic to an incoming message.
+     * @summary Receives the active configuration, original message, and context stack to produce the final message string.
+     * @param {LoggingConfig} config - Active logging configuration.
+     * @param {string} message - Message submitted for logging.
+     * @param {string[]} context - Context identifiers associated with the message.
+     * @return {string} Filtered message string.
+     */
     filter(config: LoggingConfig, message: string, context: string[]): string;
 }
 /**
@@ -136,21 +182,16 @@ export type LoggingConfig = {
     filters?: string[] | LoggingFilter[];
 };
 /**
- * @description A factory function type for creating loggers
- * @summary Defines a function type that creates and returns a logger instance for a given object
+ * @description Factory signature for creating logger instances.
+ * @summary Allows consumers to override logger construction with custom implementations.
  * @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
+ * @typedef {function(string, Partial<LoggingConfig>, any[]): L} LoggerFactory
  * @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.
+ * @description Theme option applied to a specific log element.
+ * @summary Configures foreground and background colors as well as additional style directives for styled console output.
  * @interface ThemeOption
  * @memberOf module:Logging
  */
@@ -160,28 +201,25 @@ export interface ThemeOption {
     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
+ * @description Mapping between log levels and theme overrides.
+ * @summary Enables level-specific styling by associating each {@link LogLevel} with a {@link ThemeOption} configuration.
  * @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.
+ * @description Theme definition applied to console output.
+ * @summary Specifies styling for each console log element and supports overrides based on {@link LogLevel} values.
  * @interface Theme
  * @memberOf module:Logging
  */
 export interface Theme {
     /**
-     * @description Styling for class names in the output.
+     * @description Styling for application identifiers in the output.
      */
     app: ThemeOption | ThemeOptionByLogLevel;
     /**
-     * @description Styling for class names in the output.
+     * @description Styling for separators inserted between log sections.
      */
     separator: ThemeOption | ThemeOptionByLogLevel;
     /**
@@ -205,11 +243,11 @@ export interface Theme {
      */
     id: ThemeOption | ThemeOptionByLogLevel;
     /**
-     * @description Styling for identifier elements in the output.
+     * @description Styling for stack trace blocks in the output.
      */
     stack: ThemeOption;
     /**
-     * @description Styling for different log levels in the output.
+     * @description Styling overrides keyed by {@link LogLevel}.
      */
     logLevel: ThemeOptionByLogLevel;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/logging",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "simple winston inspired wrapper for cross lib logging",
   "type": "module",
   "exports": {
@@ -32,7 +32,7 @@
     "coverage": "rimraf ./workdocs/reports/data/*.json && npm run test:all -- --coverage --config=./workdocs/reports/jest.coverage.config.ts",
     "lint": "eslint .",
     "lint-fix": "eslint --fix .",
-    "prepare-pr": "npm run repo:pr && npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
+    "prepare-pr": "npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
     "prepare-release": "npm run lint-fix && npm run build:prod && npm run coverage && npm run docs",
     "release": "./bin/tag-release.sh",
     "clean-publish": "npx clean-publish",