node-ansi-logger 3.1.0 → 3.1.1

package/dist/logger.js

@@ -1,7 +1,33 @@
+/**
+ * This file contains the AnsiLogger .
+ *
+ * @file logger.ts
+ * @author Luca Liguori
+ * @created 2023-06-01
+ * @version 3.0.2
+ * @license Apache-2.0
+ *
+ * Copyright 2024, 2025, 2026 Luca Liguori.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable no-console */
+// Node.js built-in modules
 import path from 'node:path';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import { stringify } from './stringify.js';
+// ANSI color codes and styles are defined here for use in the logger
 export const RESET = '';
 export const BRIGHT = '';
 export const DIM = '';
@@ -26,23 +52,28 @@ export const CYAN = '';
 export const LIGHT_GREY = '';
 export const GREY = '';
 export const WHITE = '';
-export const db = '';
-export const nf = '';
-export const nt = '';
-export const wr = '';
-export const er = '';
-export const ft = '';
-export const rs = '';
-export const rk = '';
-export const dn = '';
-export const gn = '';
-export const idn = '';
-export const ign = '';
-export const zb = '';
-export const hk = '';
-export const pl = '';
-export const id = '';
-export const or = '';
+// ANSI color codes short form to use in the logger
+export const db = ''; // Debug 247
+export const nf = ''; // Info 255
+export const nt = ''; // Notice
+export const wr = ''; // Warn 220
+export const er = ''; // Error
+export const ft = ''; // Fatal
+export const rs = ''; // Reset colors to default foreground and background
+export const rk = ''; // Erase from cursor
+// Used internally by plugins
+export const dn = ''; // Display name device
+export const gn = ''; // Display name group
+export const idn = ''; // Inverted display name device
+export const ign = ''; // Inverted display name group
+export const zb = ''; // Zigbee
+export const hk = ''; // Homekit
+export const pl = ''; // payload
+export const id = ''; // id or ieee_address or UUID
+export const or = ''; // history
+/**
+ * LogLevel enumeration to specify the logging level.
+ */
 export var LogLevel;
 (function (LogLevel) {
     LogLevel["NONE"] = "";
@@ -53,6 +84,9 @@ export var LogLevel;
     LogLevel["ERROR"] = "error";
     LogLevel["FATAL"] = "fatal";
 })(LogLevel || (LogLevel = {}));
+/**
+ * TimestampFormat enumeration to specify the format of timestamps in log messages.
+ */
 export var TimestampFormat;
 (function (TimestampFormat) {
     TimestampFormat[TimestampFormat["ISO"] = 0] = "ISO";
@@ -63,6 +97,7 @@ export var TimestampFormat;
     TimestampFormat[TimestampFormat["HOMEBRIDGE"] = 5] = "HOMEBRIDGE";
     TimestampFormat[TimestampFormat["CUSTOM"] = 6] = "CUSTOM";
 })(TimestampFormat || (TimestampFormat = {}));
+// Initialize the global variables
 if (typeof globalThis.__AnsiLoggerCallback__ === 'undefined')
     globalThis.__AnsiLoggerCallback__ = undefined;
 if (typeof globalThis.__AnsiLoggerCallbackLoglevel__ === 'undefined')
@@ -73,6 +108,10 @@ if (typeof globalThis.__AnsiLoggerFileLoglevel__ === 'undefined')
     globalThis.__AnsiLoggerFileLoglevel__ = undefined;
 if (typeof globalThis.__AnsiLoggerFileLogSize__ === 'undefined')
     globalThis.__AnsiLoggerFileLogSize__ = undefined;
+/**
+ * AnsiLogger provides a customizable logging utility with ANSI color support.
+ * It allows for various configurations such as enabling debug logs, customizing log name, and more.
+ */
 export class AnsiLogger {
     _extLog;
     _logName;
@@ -84,59 +123,135 @@ export class AnsiLogger {
     _logCustomTimestampFormat;
     _logTimeStampColor = '';
     _logNameColor = '';
-    _maxFileSize = 100000000;
+    _maxFileSize = 100000000; // 100MB
     logStartTime;
     callback = undefined;
+    /**
+     * Constructs a new AnsiLogger instance with optional configuration parameters.
+     *
+     * @param {AnsiLoggerParams} params - Configuration options for the logger.
+     */
     constructor(params) {
         this._extLog = params.extLog;
         this._logName = params.logName ?? 'NodeAnsiLogger';
-        this._logLevel = params.logLevel ?? (params.logDebug === true ? "debug" : "info");
+        this._logLevel = params.logLevel ?? (params.logDebug === true ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */);
         this._logWithColors = params.logWithColors ?? true;
-        this._logTimestampFormat = params.logTimestampFormat ?? 3;
+        this._logTimestampFormat = params.logTimestampFormat ?? 3 /* TimestampFormat.LOCAL_DATE_TIME */;
         this._logCustomTimestampFormat = params.logCustomTimestampFormat ?? 'yyyy-MM-dd HH:mm:ss';
         this.logStartTime = 0;
     }
+    /**
+     * Gets the name of the logger.
+     *
+     * @returns {string} The logger name.
+     */
     get logName() {
         return this._logName;
     }
+    /**
+     * Sets the log name for the logger.
+     *
+     * @param {string} name - The logger name to set.
+     */
     set logName(name) {
         this._logName = name;
     }
+    /**
+     * Gets the log level of the logger.
+     *
+     * @returns {LogLevel} The log level.
+     */
     get logLevel() {
         return this._logLevel;
     }
+    /**
+     * Sets the log level for the logger.
+     *
+     * @param {LogLevel} logLevel - The log level to set.
+     */
     set logLevel(logLevel) {
         this._logLevel = logLevel;
     }
+    /**
+     * Gets the logWithColors flag of the logger.
+     *
+     * @returns {boolean} The logWithColors parameter.
+     */
     get logWithColors() {
         return this._logWithColors;
     }
+    /**
+     * Sets the logWithColors flag of the logger.
+     *
+     * @param {boolean} logWithColors - The logWithColors parameter to set.
+     */
     set logWithColors(logWithColors) {
         this._logWithColors = logWithColors;
     }
+    /**
+     * Gets the log name color string of the logger.
+     *
+     * @returns {string} The log name color string.
+     */
     get logNameColor() {
         return this._logNameColor;
     }
+    /**
+     * Sets the log name color string for the logger.
+     *
+     * @param {string} color - The logger name color string to set.
+     */
     set logNameColor(color) {
         this._logNameColor = color;
     }
+    /**
+     * Gets the log timestamp format of the logger.
+     *
+     * @returns {TimestampFormat} The log timestamp format.
+     */
     get logTimestampFormat() {
         return this._logTimestampFormat;
     }
+    /**
+     * Sets the log timestamp format for the logger.
+     *
+     * @param {TimestampFormat} logTimestampFormat - The log timestamp format to set.
+     */
     set logTimestampFormat(logTimestampFormat) {
         this._logTimestampFormat = logTimestampFormat;
     }
+    /**
+     * Gets the custom log timestamp format of the logger.
+     *
+     * @returns {string} The custom log timestamp format.
+     */
     get logCustomTimestampFormat() {
         return this._logCustomTimestampFormat;
     }
+    /**
+     * Sets the custom log timestamp format for the logger.
+     *
+     * @param {string} logCustomTimestampFormat - The custom log timestamp format to set.
+     */
     set logCustomTimestampFormat(logCustomTimestampFormat) {
         this._logCustomTimestampFormat = logCustomTimestampFormat;
     }
+    /**
+     * Gets the file path of the log.
+     *
+     * @returns {string | undefined} The file path of the log, or undefined if not set.
+     */
     get logFilePath() {
         return this._logFilePath;
     }
+    /**
+     * Sets the file path for logging.
+     *
+     * @param {string | undefined} filePath - The file path to set for logging.
+     */
     set logFilePath(filePath) {
         if (filePath && typeof filePath === 'string' && filePath !== '') {
+            // Convert relative path to absolute path
             try {
                 this._logFilePath = path.resolve(filePath);
             }
@@ -146,6 +261,7 @@ export class AnsiLogger {
                 this._logFileSize = undefined;
                 return;
             }
+            // Check if the file exists and unlink
             if (this._logFilePath && fs.existsSync(this._logFilePath)) {
                 try {
                     fs.unlinkSync(this._logFilePath);
@@ -164,19 +280,44 @@ export class AnsiLogger {
             this._logFileSize = undefined;
         }
     }
+    /**
+     * Gets the size of log file.
+     *
+     * @returns {number | undefined} The size of log file, or undefined if not set.
+     */
     get logFileSize() {
         return this._logFilePath && this._logFileSize ? this._logFileSize : undefined;
     }
+    /**
+     * Gets the max file size of the file loggers.
+     *
+     * @returns {number} The current maxFileSize.
+     */
     get maxFileSize() {
         return this._maxFileSize;
     }
+    /**
+     * Sets the max file size of the file loggers.
+     *
+     * @param {number} maxFileSize - The maxFileSize to set.
+     */
     set maxFileSize(maxFileSize) {
-        this._maxFileSize = Math.min(maxFileSize, 500000000);
+        this._maxFileSize = Math.min(maxFileSize, 500000000); // 500MB
     }
+    /**
+     * Starts a timer with an optional message.
+     *
+     * @param {string} message - The message to log when starting the timer.
+     */
     startTimer(message) {
         this.logStartTime = Date.now();
         this.info(`Timer started ${message}`);
     }
+    /**
+     * Stops the timer started by startTimer and logs the elapsed time.
+     *
+     * @param {string} message - The message to log along with the elapsed time.
+     */
     stopTimer(message) {
         if (this.logStartTime !== 0) {
             const timePassed = Date.now() - this.logStartTime;
@@ -184,17 +325,40 @@ export class AnsiLogger {
         }
         this.logStartTime = 0;
     }
+    /**
+     * Sets the callback function to be used by the logger.
+     *
+     * @param {AnsiLoggerCallback} callback - The callback function.
+     */
     setCallback(callback) {
         this.callback = callback;
     }
+    /**
+     * Gets the callback function currently used by the logger.
+     *
+     * @returns {AnsiLoggerCallback | undefined} The callback function.
+     */
     getCallback() {
         return this.callback;
     }
-    static setGlobalCallback(callback, callbackLevel = "debug") {
+    /**
+     * Sets the global callback function to be used by the logger.
+     *
+     * @param {AnsiLoggerCallback | undefined} callback - The callback function.
+     * @param {LogLevel} [callbackLevel]  - The log level of the log file (default LogLevel.DEBUG).
+     *
+     * @returns {AnsiLoggerCallback | undefined} The path name of the log file.
+     */
+    static setGlobalCallback(callback, callbackLevel = "debug" /* LogLevel.DEBUG */) {
         __AnsiLoggerCallback__ = callback;
         __AnsiLoggerCallbackLoglevel__ = callbackLevel;
         return __AnsiLoggerCallback__;
     }
+    /**
+     * Gets the global callback function currently used by the logger.
+     *
+     * @returns {AnsiLoggerCallback | undefined} The callback function.
+     */
     static getGlobalCallback() {
         if (__AnsiLoggerCallback__) {
             return __AnsiLoggerCallback__;
@@ -203,6 +367,11 @@ export class AnsiLogger {
             return undefined;
         }
     }
+    /**
+     * Gets the global callback log level used by the logger.
+     *
+     * @returns {LogLevel | undefined} The log level of the global callback.
+     */
     static getGlobalCallbackLevel() {
         if (__AnsiLoggerCallbackLoglevel__) {
             return __AnsiLoggerCallbackLoglevel__;
@@ -211,13 +380,31 @@ export class AnsiLogger {
             return undefined;
         }
     }
-    static setGlobalCallbackLevel(logLevel = "debug") {
+    /**
+     * Sets the global callback log level for the logger.
+     *
+     * @param {LogLevel} logLevel - The log level to set. Defaults to LogLevel.DEBUG.
+     *
+     * @returns {LogLevel | undefined} The log level that was set.
+     */
+    static setGlobalCallbackLevel(logLevel = "debug" /* LogLevel.DEBUG */) {
         __AnsiLoggerCallbackLoglevel__ = logLevel;
         return __AnsiLoggerCallbackLoglevel__;
     }
-    static setGlobalLogfile(logfilePath, logfileLevel = "debug", unlink = false) {
+    /**
+     * Sets the global logfile to be used by the logger.
+     *
+     * @param {string} logfilePath - The path name of the log file.
+     * @param {LogLevel} logfileLevel - Optional: the log level of the log file. Default LogLevel.DEBUG.
+     * @param {boolean} unlink - Optional: whether to unlink (delete) the log file if it exists. Default false.
+     *
+     * @returns {string | undefined} The absolute path name of the log file.
+     */
+    static setGlobalLogfile(logfilePath, logfileLevel = "debug" /* LogLevel.DEBUG */, unlink = false) {
         if (logfilePath && typeof logfilePath === 'string' && logfilePath !== '') {
+            // Convert relative path to absolute path
             logfilePath = path.resolve(logfilePath);
+            // Check if the file exists and unlink it if requested
             if (unlink && fs.existsSync(logfilePath)) {
                 try {
                     fs.unlinkSync(logfilePath);
@@ -235,6 +422,11 @@ export class AnsiLogger {
         __AnsiLoggerFileLogSize__ = undefined;
         return undefined;
     }
+    /**
+     * Gets the global logfile currently used by the logger.
+     *
+     * @returns {string | undefined} The path name of the log file.
+     */
     static getGlobalLogfile() {
         if (__AnsiLoggerFilePath__) {
             return __AnsiLoggerFilePath__;
@@ -243,6 +435,11 @@ export class AnsiLogger {
             return undefined;
         }
     }
+    /**
+     * Gets the global logfile log level used by the loggers.
+     *
+     * @returns {LogLevel | undefined} The log level of the global logfile.
+     */
     static getGlobalLogfileLevel() {
         if (__AnsiLoggerFileLoglevel__) {
             return __AnsiLoggerFileLoglevel__;
@@ -251,50 +448,65 @@ export class AnsiLogger {
             return undefined;
         }
     }
+    /**
+     * Sets the global logfile log level used by the loggers.
+     *
+     * @param {LogLevel} logfileLevel - The global logfile log level used by the loggers.
+     *
+     * @returns {LogLevel | undefined} The log level of the global logfile.
+     */
     static setGlobalLogfileLevel(logfileLevel) {
         __AnsiLoggerFileLoglevel__ = logfileLevel;
         return __AnsiLoggerFileLoglevel__;
     }
+    /**
+     * Determines whether a log message with the given level should be logged based on the configured log level.
+     *
+     * @param {LogLevel} level - The level of the log message.
+     * @param {LogLevel | undefined} configuredLevel - The configured log level.
+     *
+     * @returns {boolean} A boolean indicating whether the log message should be logged.
+     */
     shouldLog(level, configuredLevel) {
         switch (level) {
-            case "":
+            case "" /* LogLevel.NONE */:
                 return false;
-            case "debug":
-                if (configuredLevel === "debug") {
+            case "debug" /* LogLevel.DEBUG */:
+                if (configuredLevel === "debug" /* LogLevel.DEBUG */) {
                     return true;
                 }
                 break;
-            case "info":
-                if (configuredLevel === "debug" || configuredLevel === "info") {
+            case "info" /* LogLevel.INFO */:
+                if (configuredLevel === "debug" /* LogLevel.DEBUG */ || configuredLevel === "info" /* LogLevel.INFO */) {
                     return true;
                 }
                 break;
-            case "notice":
-                if (configuredLevel === "debug" || configuredLevel === "info" || configuredLevel === "notice") {
+            case "notice" /* LogLevel.NOTICE */:
+                if (configuredLevel === "debug" /* LogLevel.DEBUG */ || configuredLevel === "info" /* LogLevel.INFO */ || configuredLevel === "notice" /* LogLevel.NOTICE */) {
                     return true;
                 }
                 break;
-            case "warn":
-                if (configuredLevel === "debug" || configuredLevel === "info" || configuredLevel === "notice" || configuredLevel === "warn") {
+            case "warn" /* LogLevel.WARN */:
+                if (configuredLevel === "debug" /* LogLevel.DEBUG */ || configuredLevel === "info" /* LogLevel.INFO */ || configuredLevel === "notice" /* LogLevel.NOTICE */ || configuredLevel === "warn" /* LogLevel.WARN */) {
                     return true;
                 }
                 break;
-            case "error":
-                if (configuredLevel === "debug" ||
-                    configuredLevel === "info" ||
-                    configuredLevel === "notice" ||
-                    configuredLevel === "warn" ||
-                    configuredLevel === "error") {
+            case "error" /* LogLevel.ERROR */:
+                if (configuredLevel === "debug" /* LogLevel.DEBUG */ ||
+                    configuredLevel === "info" /* LogLevel.INFO */ ||
+                    configuredLevel === "notice" /* LogLevel.NOTICE */ ||
+                    configuredLevel === "warn" /* LogLevel.WARN */ ||
+                    configuredLevel === "error" /* LogLevel.ERROR */) {
                     return true;
                 }
                 break;
-            case "fatal":
-                if (configuredLevel === "debug" ||
-                    configuredLevel === "info" ||
-                    configuredLevel === "notice" ||
-                    configuredLevel === "warn" ||
-                    configuredLevel === "error" ||
-                    configuredLevel === "fatal") {
+            case "fatal" /* LogLevel.FATAL */:
+                if (configuredLevel === "debug" /* LogLevel.DEBUG */ ||
+                    configuredLevel === "info" /* LogLevel.INFO */ ||
+                    configuredLevel === "notice" /* LogLevel.NOTICE */ ||
+                    configuredLevel === "warn" /* LogLevel.WARN */ ||
+                    configuredLevel === "error" /* LogLevel.ERROR */ ||
+                    configuredLevel === "fatal" /* LogLevel.FATAL */) {
                     return true;
                 }
                 break;
@@ -303,13 +515,23 @@ export class AnsiLogger {
         }
         return false;
     }
+    /**
+     * Formats a Date object into a custom string format.
+     *
+     * @param {Date} date - The Date object to format.
+     * @param {string} formatString - The string format to use.
+     * @returns {string} The formatted date.
+     * It only handles years, months, days, hours, minutes, and seconds
+     * with this format 'yyyy-MM-dd HH:mm:ss'
+     */
     formatCustomTimestamp(date, formatString) {
         const year = date.getFullYear();
-        const month = date.getMonth() + 1;
+        const month = date.getMonth() + 1; // getMonth() returns 0-11
         const day = date.getDate();
         const hours = date.getHours();
         const minutes = date.getMinutes();
         const seconds = date.getSeconds();
+        // Replace format tokens with actual values. Add more as needed.
         return formatString
             .replace('yyyy', year.toString())
             .replace('MM', month.toString().padStart(2, '0'))
@@ -318,9 +540,21 @@ export class AnsiLogger {
             .replace('mm', minutes.toString().padStart(2, '0'))
             .replace('ss', seconds.toString().padStart(2, '0'));
     }
+    /**
+     * Returns the current timestamp as a string.
+     *
+     * @returns {string} The current timestamp.
+     */
     now() {
         return this.getTimestamp();
     }
+    /**
+     * Returns the timestamp based on the configured format.
+     * If the log start time is set, it returns the time passed since the start time.
+     * Otherwise, it returns the current timestamp based on the configured format.
+     *
+     * @returns {string} The timestamp string.
+     */
     getTimestamp() {
         if (this.logStartTime !== 0) {
             const timePassed = Date.now() - this.logStartTime;
@@ -329,23 +563,23 @@ export class AnsiLogger {
         else {
             let timestamp;
             switch (this._logTimestampFormat) {
-                case 1:
+                case 1 /* TimestampFormat.LOCAL_DATE */:
                     timestamp = new Date().toLocaleDateString();
                     break;
-                case 2:
+                case 2 /* TimestampFormat.LOCAL_TIME */:
                     timestamp = new Date().toLocaleTimeString();
                     break;
-                case 5:
-                case 3:
+                case 5 /* TimestampFormat.HOMEBRIDGE */:
+                case 3 /* TimestampFormat.LOCAL_DATE_TIME */:
                     timestamp = new Date().toLocaleString();
                     break;
-                case 0:
+                case 0 /* TimestampFormat.ISO */:
                     timestamp = new Date().toISOString();
                     break;
-                case 4:
+                case 4 /* TimestampFormat.TIME_MILLIS */:
                     timestamp = `${new Date().getHours().toString().padStart(2, '0')}:${new Date().getMinutes().toString().padStart(2, '0')}:${new Date().getSeconds().toString().padStart(2, '0')}.${new Date().getMilliseconds().toString().padStart(3, '0')}`;
                     break;
-                case 6:
+                case 6 /* TimestampFormat.CUSTOM */:
                     timestamp = this.formatCustomTimestamp(new Date(), this._logCustomTimestampFormat);
                     break;
                 default:
@@ -355,6 +589,16 @@ export class AnsiLogger {
             return timestamp;
         }
     }
+    /**
+     * Writes a log message to a file.
+     *
+     * @param {string} filePath - The path of the file to write the log message to.
+     * @param {LogLevel} level - The log level of the message.
+     * @param {string} message - The log message.
+     * @param {...any[]} parameters - Additional parameters to include in the log message.
+     * @returns {number} - The length of the log message including the appended newline character.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     logToFile(filePath, level, message, ...parameters) {
         const parametersString = parameters
             .map((parameter) => {
@@ -367,6 +611,8 @@ export class AnsiLogger {
                     return stringify(parameter);
                 case 'string':
                     return parameter;
+                // case 'undefined':
+                // return 'undefined';
                 case 'function':
                     return '(function)';
                 default:
@@ -375,7 +621,9 @@ export class AnsiLogger {
         })
             .join(' ');
         let messageLog = `[${this.getTimestamp()}] [${this._logName}] [${level}] ` + message + ' ' + parametersString;
+        // messageLog = messageLog.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '').replace(/[\t\n\r]/g, '');
         messageLog = messageLog
+            // eslint-disable-next-line no-control-regex
             .replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '')
             .replaceAll('\t', ' ')
             .replaceAll('\r', '')
@@ -383,16 +631,28 @@ export class AnsiLogger {
         fs.appendFileSync(filePath, messageLog + os.EOL);
         return messageLog.length + 1;
     }
+    /**
+     * Logs a message with a specific level (e.g. debug, info, notice, warn, error, fatal) and additional parameters.
+     * This method formats the log message with ANSI colors based on the log level and other logger settings.
+     * It supports dynamic parameters for more detailed and formatted logging.
+     *
+     * @param {LogLevel} level - The severity level of the log message.
+     * @param {string} message - The primary log message to be displayed.
+     * @param {...any[]} parameters - Additional parameters to be logged. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(level, message, ...parameters) {
-        const s1ln = '';
-        const s2ln = '';
-        const s3ln = '';
-        const s4ln = '';
+        const s1ln = ''; // Highlight  LogName Black on Cyan
+        const s2ln = ''; // Highlight  LogName Black on White
+        const s3ln = ''; // Highlight  LogName Black on Yellow
+        const s4ln = ''; // Highlight  LogName Black on Red
         if (typeof level !== 'string' || level.startsWith === undefined || typeof message !== 'string' || message.startsWith === undefined) {
             return;
         }
+        // Local callback
         try {
             if (this.callback !== undefined && this.shouldLog(level, this._logLevel)) {
+                // Convert parameters to string and append to message
                 const parametersString = parameters.length > 0 ? ' ' + parameters.join(' ') : '';
                 const newMessage = message + parametersString;
                 this.callback(level, this.getTimestamp(), this._logName, newMessage);
@@ -401,8 +661,10 @@ export class AnsiLogger {
         catch (error) {
             console.error('Error executing local callback:', error);
         }
+        // Global callback
         try {
             if (__AnsiLoggerCallback__ && __AnsiLoggerCallback__ !== undefined && this.shouldLog(level, __AnsiLoggerCallbackLoglevel__)) {
+                // Convert parameters to string and append to message
                 const parametersString = parameters.length > 0 ? ' ' + parameters.join(' ') : '';
                 const newMessage = message + parametersString;
                 __AnsiLoggerCallback__(level, this.getTimestamp(), this._logName, newMessage);
@@ -411,6 +673,7 @@ export class AnsiLogger {
         catch (error) {
             console.error('Error executing global callback:', error);
         }
+        // Local file logger
         try {
             if (this.logFilePath !== undefined && this._logFileSize !== undefined && this._logFileSize < this._maxFileSize && this.shouldLog(level, this._logLevel)) {
                 const size = this.logToFile(this.logFilePath, level, message, ...parameters);
@@ -423,6 +686,7 @@ export class AnsiLogger {
         catch (error) {
             console.error(`Error writing to the local log file ${this.logFilePath}:`, error);
         }
+        // Global file logger
         try {
             if (__AnsiLoggerFilePath__ &&
                 __AnsiLoggerFilePath__ !== undefined &&
@@ -440,7 +704,7 @@ export class AnsiLogger {
             console.error(`Error writing to the global log file ${__AnsiLoggerFilePath__}:`, error);
         }
         if (this._extLog !== undefined) {
-            if (level !== "") {
+            if (level !== "" /* LogLevel.NONE */) {
                 this._extLog.log(level, message, ...parameters);
             }
         }
@@ -464,32 +728,32 @@ export class AnsiLogger {
                     message = message.slice(1);
                 }
                 switch (level) {
-                    case "debug":
+                    case "debug" /* LogLevel.DEBUG */:
                         if (this.shouldLog(level, this._logLevel)) {
                             console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${db}`, message + rs + rk, ...parameters);
                         }
                         break;
-                    case "info":
+                    case "info" /* LogLevel.INFO */:
                         if (this.shouldLog(level, this._logLevel)) {
                             console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${nf}`, message + rs + rk, ...parameters);
                         }
                         break;
-                    case "notice":
+                    case "notice" /* LogLevel.NOTICE */:
                         if (this.shouldLog(level, this._logLevel)) {
                             console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${nt}`, message + rs + rk, ...parameters);
                         }
                         break;
-                    case "warn":
+                    case "warn" /* LogLevel.WARN */:
                         if (this.shouldLog(level, this._logLevel)) {
                             console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${wr}`, message + rs + rk, ...parameters);
                         }
                         break;
-                    case "error":
+                    case "error" /* LogLevel.ERROR */:
                         if (this.shouldLog(level, this._logLevel)) {
                             console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${er}`, message + rs + rk, ...parameters);
                         }
                         break;
-                    case "fatal":
+                    case "fatal" /* LogLevel.FATAL */:
                         if (this.shouldLog(level, this._logLevel)) {
                             console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${ft}`, message + rs + rk, ...parameters);
                         }
@@ -500,42 +764,42 @@ export class AnsiLogger {
             }
             else {
                 switch (level) {
-                    case "debug":
-                        if (this._logLevel === "debug") {
+                    case "debug" /* LogLevel.DEBUG */:
+                        if (this._logLevel === "debug" /* LogLevel.DEBUG */) {
                             console.log(`[${this.getTimestamp()}] [${this._logName}] [${level}] ${message}`, ...parameters);
                         }
                         break;
-                    case "info":
-                        if (this._logLevel === "debug" || this._logLevel === "info") {
+                    case "info" /* LogLevel.INFO */:
+                        if (this._logLevel === "debug" /* LogLevel.DEBUG */ || this._logLevel === "info" /* LogLevel.INFO */) {
                             console.log(`[${this.getTimestamp()}] [${this._logName}] [${level}] ${message}`, ...parameters);
                         }
                         break;
-                    case "notice":
-                        if (this._logLevel === "debug" || this._logLevel === "info" || this._logLevel === "notice") {
+                    case "notice" /* LogLevel.NOTICE */:
+                        if (this._logLevel === "debug" /* LogLevel.DEBUG */ || this._logLevel === "info" /* LogLevel.INFO */ || this._logLevel === "notice" /* LogLevel.NOTICE */) {
                             console.log(`[${this.getTimestamp()}] [${this._logName}] [${level}] ${message}`, ...parameters);
                         }
                         break;
-                    case "warn":
-                        if (this._logLevel === "debug" || this._logLevel === "info" || this._logLevel === "notice" || this._logLevel === "warn") {
+                    case "warn" /* LogLevel.WARN */:
+                        if (this._logLevel === "debug" /* LogLevel.DEBUG */ || this._logLevel === "info" /* LogLevel.INFO */ || this._logLevel === "notice" /* LogLevel.NOTICE */ || this._logLevel === "warn" /* LogLevel.WARN */) {
                             console.log(`[${this.getTimestamp()}] [${this._logName}] [${level}] ${message}`, ...parameters);
                         }
                         break;
-                    case "error":
-                        if (this._logLevel === "debug" ||
-                            this._logLevel === "info" ||
-                            this._logLevel === "notice" ||
-                            this._logLevel === "warn" ||
-                            this._logLevel === "error") {
+                    case "error" /* LogLevel.ERROR */:
+                        if (this._logLevel === "debug" /* LogLevel.DEBUG */ ||
+                            this._logLevel === "info" /* LogLevel.INFO */ ||
+                            this._logLevel === "notice" /* LogLevel.NOTICE */ ||
+                            this._logLevel === "warn" /* LogLevel.WARN */ ||
+                            this._logLevel === "error" /* LogLevel.ERROR */) {
                             console.log(`[${this.getTimestamp()}] [${this._logName}] [${level}] ${message}`, ...parameters);
                         }
                         break;
-                    case "fatal":
-                        if (this._logLevel === "debug" ||
-                            this._logLevel === "info" ||
-                            this._logLevel === "notice" ||
-                            this._logLevel === "warn" ||
-                            this._logLevel === "error" ||
-                            this._logLevel === "fatal") {
+                    case "fatal" /* LogLevel.FATAL */:
+                        if (this._logLevel === "debug" /* LogLevel.DEBUG */ ||
+                            this._logLevel === "info" /* LogLevel.INFO */ ||
+                            this._logLevel === "notice" /* LogLevel.NOTICE */ ||
+                            this._logLevel === "warn" /* LogLevel.WARN */ ||
+                            this._logLevel === "error" /* LogLevel.ERROR */ ||
+                            this._logLevel === "fatal" /* LogLevel.FATAL */) {
                             console.log(`[${this.getTimestamp()}] [${this._logName}] [${level}] ${message}`, ...parameters);
                         }
                         break;
@@ -545,22 +809,108 @@ export class AnsiLogger {
             }
         }
     }
+    /**
+     * Logs a debug message if debug logging is enabled. This is a convenience method that delegates to the `log` method with the `LogLevel.DEBUG` level.
+     *
+     * @param {string} message - The message to log.
+     * @param {...any[]} parameters - Additional parameters to be included in the log message. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     debug(message, ...parameters) {
-        this.log("debug", message, ...parameters);
-    }
+        this.log("debug" /* LogLevel.DEBUG */, message, ...parameters);
+    }
+    /**
+     * Logs an informational message. This is a convenience method that delegates to the `log` method with the `LogLevel.INFO` level.
+     *
+     * @param {string} message - The message to log.
+     * @param {...any[]} parameters - Additional parameters to be included in the log message. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     info(message, ...parameters) {
-        this.log("info", message, ...parameters);
-    }
+        this.log("info" /* LogLevel.INFO */, message, ...parameters);
+    }
+    /**
+     * Logs a notice message. This is a convenience method that delegates to the `log` method with the `LogLevel.NOTICE` level.
+     *
+     * @param {string} message - The message to log.
+     * @param {...any[]} parameters - Additional parameters to be included in the log message. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     notice(message, ...parameters) {
-        this.log("notice", message, ...parameters);
-    }
+        this.log("notice" /* LogLevel.NOTICE */, message, ...parameters);
+    }
+    /**
+     * Logs a warning message. This is a convenience method that delegates to the `log` method with the `LogLevel.WARN` level.
+     *
+     * @param {string} message - The message to log.
+     * @param {...any[]} parameters - Additional parameters to be included in the log message. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     warn(message, ...parameters) {
-        this.log("warn", message, ...parameters);
-    }
+        this.log("warn" /* LogLevel.WARN */, message, ...parameters);
+    }
+    /**
+     * Logs an error message. This is a convenience method that delegates to the `log` method with the `LogLevel.ERROR` level.
+     *
+     * @param {string} message - The message to log.
+     * @param {...any[]} parameters - Additional parameters to be included in the log message. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     error(message, ...parameters) {
-        this.log("error", message, ...parameters);
-    }
+        this.log("error" /* LogLevel.ERROR */, message, ...parameters);
+    }
+    /**
+     * Logs a fatal message. This is a convenience method that delegates to the `log` method with the `LogLevel.FATAL` level.
+     *
+     * @param {string} message - The message to log.
+     * @param {...any[]} parameters - Additional parameters to be included in the log message. Supports any number of parameters.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     fatal(message, ...parameters) {
-        this.log("fatal", message, ...parameters);
+        this.log("fatal" /* LogLevel.FATAL */, message, ...parameters);
     }
 }
+/*
+     - Reset (clear color)
+     - Bold
+     - Italic
+     - Underline
+      - Erase the line from cursor
+
+     - Black
+     - Red
+     - Green
+     - Yellow
+     - Blue
+     - Magenta
+     - Cyan
+     - White
+
+    [90-97m - Bright
+
+     - Black background
+     - Red background
+     - Green background
+     - Yellow background
+     - Blue background
+     - Magenta background
+     - Cyan background
+     - White background
+
+    [100-107m - Bright background
+
+     // Orange
+
+    RGB foreground
+    [38;2;<R>;<G>;<B>m
+
+    RGB background
+    [48;2;<R>;<G>;<B>m
+
+    256 colors foreground
+    [38;5;<FG COLOR>m
+
+    256 colors background
+    [48;5;<BG COLOR>m
+*/
+//# sourceMappingURL=logger.js.map