node-ansi-logger 2.0.7 → 3.0.0

package/dist/logger.js

@@ -22,52 +22,53 @@
  * limitations under the License.
  */
 import path from 'path';
-import { colorStringify, debugStringify, historyStringify, mqttStringify, payloadStringify } from './stringify.js';
+import { stringify } from './stringify.js';
 import * as fs from 'fs';
+import * as os from 'os';
 // ANSI color codes and styles are defined here for use in the logger
-export const RESET = '\x1b[40;0m';
-export const BRIGHT = '\x1b[1m';
-export const DIM = '\x1b[2m';
-export const NORMAL = '\x1b[22m';
-export const UNDERLINE = '\x1b[4m';
-export const UNDERLINEOFF = '\x1b[24m';
-export const BLINK = '\x1b[5m';
-export const BLINKOFF = '\x1b[25m';
-export const REVERSE = '\x1b[7m';
-export const REVERSEOFF = '\x1b[27m';
-export const HIDDEN = '\x1b[8m';
-export const HIDDENOFF = '\x1b[28m';
-export const CURSORSAVE = '\x1b[s';
-export const CURSORRESTORE = '\x1b[u';
-export const BLACK = '\x1b[30m';
-export const RED = '\x1b[31m';
-export const GREEN = '\x1b[32m';
-export const YELLOW = '\x1b[33m';
-export const BLUE = '\x1b[34m';
-export const MAGENTA = '\x1b[35m';
-export const CYAN = '\x1b[36m';
-export const LIGHT_GREY = '\x1b[37m';
-export const GREY = '\x1b[90m';
-export const WHITE = '\x1b[97m';
+export const RESET = '';
+export const BRIGHT = '';
+export const DIM = '';
+export const NORMAL = '';
+export const UNDERLINE = '';
+export const UNDERLINEOFF = '';
+export const BLINK = '';
+export const BLINKOFF = '';
+export const REVERSE = '';
+export const REVERSEOFF = '';
+export const HIDDEN = '';
+export const HIDDENOFF = '';
+export const CURSORSAVE = '';
+export const CURSORRESTORE = '';
+export const BLACK = '';
+export const RED = '';
+export const GREEN = '';
+export const YELLOW = '';
+export const BLUE = '';
+export const MAGENTA = '';
+export const CYAN = '';
+export const LIGHT_GREY = '';
+export const GREY = '';
+export const WHITE = '';
 // ANSI color codes short form to use in the logger
-export const db = '\x1b[38;5;245m'; // Debug 247
-export const nf = '\x1b[38;5;252m'; // Info 255
-export const nt = '\x1b[38;5;2m'; // Notice
-export const wr = '\x1b[38;5;220m'; // Warn 220
-export const er = '\x1b[38;5;1m'; // Error
-export const ft = '\x1b[38;5;9m'; // Fatal
-export const rs = '\x1b[40;0m'; // Reset colors to default foreground and background
-export const rk = '\x1b[K'; // Erase from cursor
+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 = '\x1b[38;5;33m'; // Display name device
-export const gn = '\x1b[38;5;35m'; // Display name group
-export const idn = '\x1b[48;5;21m\x1b[38;5;255m'; // Inverted display name device
-export const ign = '\x1b[48;5;22m\x1b[38;5;255m'; // Inverted display name group
-export const zb = '\x1b[38;5;207m'; // Zigbee
-export const hk = '\x1b[38;5;79m'; // Homekit
-export const pl = '\x1b[32m'; // payload
-export const id = '\x1b[37;44m'; // id or ieee_address or UUID
-export const or = '\x1b[38;5;208m'; // history
+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.
  */
@@ -103,18 +104,24 @@ if (typeof globalThis.__AnsiLoggerFilePath__ === 'undefined')
     globalThis.__AnsiLoggerFilePath__ = undefined;
 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 {
-    _hbLog;
+    _extLog;
     _logName;
     _logFilePath;
+    _logFileSize;
     _logLevel;
     _logWithColors;
     _logTimestampFormat;
     _logCustomTimestampFormat;
+    _logTimeStampColor = '';
+    _logNameColor = '';
+    _maxFileSize = 100000000; // 100MB
     logStartTime;
     callback = undefined;
     /**
@@ -122,7 +129,7 @@ export class AnsiLogger {
      * @param {AnsiLoggerParams} optionalParams - Configuration options for the logger.
      */
     constructor(params) {
-        this._hbLog = params.hbLog;
+        this._extLog = params.extLog;
         this._logName = params.logName ?? 'NodeAnsiLogger';
         this._logLevel = params.logLevel ?? (params.logDebug === true ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */);
         this._logWithColors = params.logWithColors ?? true;
@@ -144,25 +151,6 @@ export class AnsiLogger {
     set logName(name) {
         this._logName = name;
     }
-    /**
-     * Sets the name of the logger.
-     * @param {string} name - The new name for the logger.
-     * @deprecated Use logName getter and setter instead.
-     */
-    setLogName(name) {
-        this.logName = name;
-    }
-    /**
-     * Enables or disables debug logging.
-     * @param {boolean} logDebug - Flag to enable or disable debug logging.
-     * @deprecated Use logLevel getter and setter instead.
-     */
-    setLogDebug(logDebug) {
-        if (logDebug)
-            this.logLevel = "debug" /* LogLevel.DEBUG */;
-        else
-            this.logLevel = "info" /* LogLevel.INFO */;
-    }
     /**
      * Gets the log level of the logger.
      * @returns {LogLevel} The log level.
@@ -191,6 +179,50 @@ export class AnsiLogger {
     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.
      *
@@ -202,19 +234,21 @@ export class AnsiLogger {
     /**
      * Sets the file path for logging.
      *
-     * @param {string | undefined} value - The file path to set for logging.
+     * @param {string | undefined} filePath - The file path to set for logging.
      */
-    set logFilePath(value) {
-        if (value && typeof value === 'string' && value !== '') {
+    set logFilePath(filePath) {
+        if (filePath && typeof filePath === 'string' && filePath !== '') {
             // Convert relative path to absolute path
             try {
-                this._logFilePath = path.resolve(value);
+                this._logFilePath = path.resolve(filePath);
             }
             catch (error) {
-                console.error(`Error resolving log file path: ${error instanceof Error ? error.message : error}`);
+                console.error(`Error resolving log file path ${CYAN}${filePath}${er}: ${error instanceof Error ? error.message : error}`);
                 this._logFilePath = undefined;
+                this._logFileSize = undefined;
                 return;
             }
+            // Check if the file exists and unlink
             if (this._logFilePath && fs.existsSync(this._logFilePath)) {
                 try {
                     fs.unlinkSync(this._logFilePath);
@@ -222,34 +256,38 @@ export class AnsiLogger {
                 catch (error) {
                     console.error(`${er}Error unlinking the log file ${CYAN}${this._logFilePath}${er}: ${error instanceof Error ? error.message : error}`);
                     this._logFilePath = undefined;
+                    this._logFileSize = undefined;
+                    return;
                 }
             }
+            this._logFileSize = 0;
         }
         else {
             this._logFilePath = undefined;
+            this._logFileSize = undefined;
         }
     }
     /**
-     * Enables or disables logging with ANSI colors.
-     * @param {boolean} logWithColors - Flag to enable or disable ANSI color logging.
-     * @deprecated Use logWithColors getter and setter instead.
+     * Gets the size of log file.
+     *
+     * @returns {number | undefined} The size of log file, or undefined if not set.
      */
-    setlogWithColors(logWithColors) {
-        this._logWithColors = logWithColors;
+    get logFileSize() {
+        return this._logFilePath && this._logFileSize ? this._logFileSize : undefined;
     }
     /**
-     * Sets the timestamp format for log messages.
-     * @param {TimestampFormat} format - The timestamp format to use.
+     * Gets the max file size of the file loggers.
+     * @returns {number} The current maxFileSize.
      */
-    setLogTimestampFormat(format) {
-        this._logTimestampFormat = format;
+    get maxFileSize() {
+        return this._maxFileSize;
     }
     /**
-     * Sets a custom timestamp format for log messages.
-     * @param {string} format - The custom timestamp format string.
+     * Sets the max file size of the file loggers.
+     * @param {number} maxFileSize - The maxFileSize to set.
      */
-    setLogCustomTimestampFormat(format) {
-        this._logCustomTimestampFormat = format;
+    set maxFileSize(maxFileSize) {
+        this._maxFileSize = Math.min(maxFileSize, 100000000); // 100MB
     }
     /**
      * Starts a timer with an optional message.
@@ -286,8 +324,8 @@ export class AnsiLogger {
     }
     /**
      * Sets the global callback function to be used by the logger.
-     * @param {AnsiLoggerCallback} callback - The callback function.
-     * @param {LogLevel} callbackLevel - The log level of the log file.
+     * @param {AnsiLoggerCallback | undefined} callback - The callback function.
+     * @param {LogLevel} [callbackLevel=LogLevel.DEBUG]  - The log level of the log file (default LogLevel.DEBUG).
      *
      * @returns {AnsiLoggerCallback | undefined} The path name of the log file.
      */
@@ -321,18 +359,30 @@ export class AnsiLogger {
             return undefined;
         }
     }
+    /**
+     * 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__;
+    }
     /**
      * Sets the global logfile to be used by the logger.
      * @param {string} logfilePath - The path name of the log file.
-     * @param {LogLevel} logfileLevel - The log level of the log file.
-     * @param {boolean} unlink - Whether to unlink (delete) the log file if it exists Default false.
+     * @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) {
+        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);
@@ -341,10 +391,14 @@ export class AnsiLogger {
                     console.error(`${er}Error unlinking the log file ${CYAN}${logfilePath}${er}: ${error instanceof Error ? error.message : error}`);
                 }
             }
+            __AnsiLoggerFilePath__ = logfilePath;
+            __AnsiLoggerFileLoglevel__ = logfileLevel;
+            __AnsiLoggerFileLogSize__ = 0;
+            return __AnsiLoggerFilePath__;
         }
-        __AnsiLoggerFilePath__ = logfilePath;
-        __AnsiLoggerFileLoglevel__ = logfileLevel;
-        return __AnsiLoggerFilePath__;
+        __AnsiLoggerFilePath__ = undefined;
+        __AnsiLoggerFileLogSize__ = undefined;
+        return undefined;
     }
     /**
      * Gets the global logfile currently used by the logger.
@@ -360,9 +414,9 @@ export class AnsiLogger {
         }
     }
     /**
-     * Gets the global logfile log level used by the logger.
+     * Gets the global logfile log level used by the loggers.
      *
-     * @returns {LogLevel | undefined} The log level of the log file.
+     * @returns {LogLevel | undefined} The log level of the global logfile.
      */
     static getGlobalLogfileLevel() {
         if (__AnsiLoggerFileLoglevel__) {
@@ -372,6 +426,17 @@ 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.
      *
@@ -382,6 +447,8 @@ export class AnsiLogger {
      */
     shouldLog(level, configuredLevel) {
         switch (level) {
+            case "" /* LogLevel.NONE */:
+                return false;
             case "debug" /* LogLevel.DEBUG */:
                 if (configuredLevel === "debug" /* LogLevel.DEBUG */) {
                     return true;
@@ -495,6 +562,15 @@ 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
@@ -503,30 +579,30 @@ export class AnsiLogger {
                 return 'null';
             if (parameter === undefined)
                 return 'undefined';
-            if (Array.isArray(parameter)) {
-                return ('[' +
-                    parameter.map((item) => (item === null ? 'null' : item === undefined ? 'undefined' : typeof item === 'object' ? debugStringify(item) : item.toString())).join(', ') +
-                    ']');
-            }
             switch (typeof parameter) {
                 case 'object':
-                    return debugStringify(parameter);
+                    return stringify(parameter);
                 case 'string':
                     return parameter;
                 case 'undefined':
                     return 'undefined';
                 case 'function':
-                    return 'function';
+                    return '(function)';
                 default:
                     return parameter.toString();
             }
         })
             .join(' ');
-        let messageLog = `[${this.getTimestamp()}] [${this._logName}] [${level}] ` + message + parametersString;
+        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, '');
-        // eslint-disable-next-line no-control-regex
-        messageLog = messageLog.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
-        fs.appendFileSync(filePath, messageLog + '\n');
+        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', '')
+            .replaceAll('\n', os.EOL);
+        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.
@@ -539,12 +615,14 @@ export class AnsiLogger {
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(level, message, ...parameters) {
-        const ts = '\x1b[38;5;245m'; // TimeStamp  White medium
-        const ln = '\x1b[38;5;31m'; // LogName    Cyan
-        const s1ln = '\x1b[38;5;0;48;5;31m'; // Highlight  LogName Black on Cyan
-        const s2ln = '\x1b[38;5;0;48;5;255m'; // Highlight  LogName Black on White
-        const s3ln = '\x1b[38;5;0;48;5;220m'; // Highlight  LogName Black on Yellow
-        const s4ln = '\x1b[38;5;0;48;5;9m'; // Highlight  LogName Black on Red
+        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
@@ -556,6 +634,7 @@ 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
@@ -567,34 +646,45 @@ export class AnsiLogger {
         catch (error) {
             console.error('Error executing global callback:', error);
         }
+        // Local file logger
         try {
-            if (this.logFilePath && this.shouldLog(level, this._logLevel)) {
-                this.logToFile(this.logFilePath, level, message, ...parameters);
+            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);
+                this._logFileSize += size;
+                if (this._logFileSize >= this._maxFileSize) {
+                    fs.appendFileSync(this.logFilePath, 'Logging on file has been stoppped because the file size is greater then 100MB.\n');
+                }
             }
         }
         catch (error) {
             console.error(`Error writing to the local log file ${this.logFilePath}:`, error);
         }
+        // Global file logger
         try {
-            if (__AnsiLoggerFilePath__ && __AnsiLoggerFilePath__ !== undefined && this.shouldLog(level, __AnsiLoggerFileLoglevel__)) {
-                this.logToFile(__AnsiLoggerFilePath__, level, message, ...parameters);
+            if (__AnsiLoggerFilePath__ &&
+                __AnsiLoggerFilePath__ !== undefined &&
+                __AnsiLoggerFileLogSize__ !== undefined &&
+                __AnsiLoggerFileLogSize__ < this._maxFileSize &&
+                this.shouldLog(level, __AnsiLoggerFileLoglevel__)) {
+                const size = this.logToFile(__AnsiLoggerFilePath__, level, message, ...parameters);
+                __AnsiLoggerFileLogSize__ += size;
+                if (__AnsiLoggerFileLogSize__ >= this._maxFileSize) {
+                    fs.appendFileSync(__AnsiLoggerFilePath__, 'Logging on file has been stoppped because the file size is greater then 100MB.\n');
+                }
             }
         }
         catch (error) {
             console.error(`Error writing to the global log file ${__AnsiLoggerFilePath__}:`, error);
         }
-        if (this._hbLog !== undefined) {
+        if (this._extLog !== undefined) {
             if (level !== "" /* LogLevel.NONE */) {
-                this._hbLog.log(level, message, ...parameters);
+                this._extLog.log(level, message, ...parameters);
             }
         }
         else {
             if (this._logWithColors) {
-                let logNameColor = ln;
-                if (typeof message !== 'string' || message.startsWith === undefined) {
-                    logNameColor = ln;
-                }
-                else if (message.startsWith('****')) {
+                let logNameColor = this._logNameColor;
+                if (message.startsWith('****')) {
                     logNameColor = s4ln;
                     message = message.slice(4);
                 }
@@ -613,32 +703,32 @@ export class AnsiLogger {
                 switch (level) {
                     case "debug" /* LogLevel.DEBUG */:
                         if (this.shouldLog(level, this._logLevel)) {
-                            console.log(`${rs}${ts}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${db}`, message + rs + rk, ...parameters);
+                            console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${db}`, message + rs + rk, ...parameters);
                         }
                         break;
                     case "info" /* LogLevel.INFO */:
                         if (this.shouldLog(level, this._logLevel)) {
-                            console.log(`${rs}${ts}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${nf}`, message + rs + rk, ...parameters);
+                            console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${nf}`, message + rs + rk, ...parameters);
                         }
                         break;
                     case "notice" /* LogLevel.NOTICE */:
                         if (this.shouldLog(level, this._logLevel)) {
-                            console.log(`${rs}${ts}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${nt}`, message + rs + rk, ...parameters);
+                            console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${nt}`, message + rs + rk, ...parameters);
                         }
                         break;
                     case "warn" /* LogLevel.WARN */:
                         if (this.shouldLog(level, this._logLevel)) {
-                            console.log(`${rs}${ts}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${wr}`, message + rs + rk, ...parameters);
+                            console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${wr}`, message + rs + rk, ...parameters);
                         }
                         break;
                     case "error" /* LogLevel.ERROR */:
                         if (this.shouldLog(level, this._logLevel)) {
-                            console.log(`${rs}${ts}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${er}`, message + rs + rk, ...parameters);
+                            console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${er}`, message + rs + rk, ...parameters);
                         }
                         break;
                     case "fatal" /* LogLevel.FATAL */:
                         if (this.shouldLog(level, this._logLevel)) {
-                            console.log(`${rs}${ts}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${ft}`, message + rs + rk, ...parameters);
+                            console.log(`${rs}${this._logTimeStampColor}[${this.getTimestamp()}] ${logNameColor}[${this._logName}]${rs}${ft}`, message + rs + rk, ...parameters);
                         }
                         break;
                     default:
@@ -754,94 +844,102 @@ export class AnsiLogger {
     }
 }
 // Use with node dist/logger.js --testAnsiLoggerColors to test ANSI colors
+/*
 if (process.argv.includes('--testAnsiLoggerColors')) {
-    for (let i = 0; i < 256; i++) {
-        console.log(`\x1b[38;5;${i}mForeground color ${i.toString().padStart(3, ' ')} \x1b[1mbright\x1b[0m`);
-    }
-    console.log(`${db}Debug message${rs}`);
-    console.log(`${nf}Info message${rs}`);
-    console.log(`${nt}Notice message${rs}`);
-    console.log(`${wr}Warn message${rs}`);
-    console.log(`${er}Error message${rs}`);
-    console.log(`${ft}Fatal message${rs}`);
-    console.log(`${nf}Stringify payload: ${payloadStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined })}${rs}`);
-    console.log(`${nf}Stringify color: ${colorStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined })}${rs}`);
-    console.log(`${nf}Stringify history: ${historyStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined })}${rs}`);
-    console.log(`${nf}Stringify mqtt: ${mqttStringify({
-        number: 1234,
-        string: 'Text',
-        boolean: true,
-        null: null,
-        undefined: undefined,
-        function: () => {
-            //
-        },
-    })}${rs}`);
-    console.log(`${db}Stringify debug: ${debugStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined, object: { number: 1234, string: 'Text', boolean: true } })}${rs}`);
-    const logger = new AnsiLogger({ logName: 'TestLogger', logLevel: "debug" /* LogLevel.DEBUG */, logWithColors: true, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */ });
-    AnsiLogger.setGlobalLogfile('test.log');
-    logger.debug('Debug message');
-    logger.info('Info message');
-    logger.notice('Notice message');
-    logger.warn('Warn message');
-    logger.error('Error message');
-    logger.fatal('Fatal message');
-    const obj = {
-        logName: 'TestLogger',
-        logLevel: "debug" /* LogLevel.DEBUG */,
-        logWithColors: true,
-        logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */,
-    };
-    logger.log("debug" /* LogLevel.DEBUG */, `Debug message with params: ${rs}\n`, obj);
-    logger.log("debug" /* LogLevel.DEBUG */, `Debug message with params: ${rs}\n`, obj, 123, 212121111111111122121n, 'Text', true, null, undefined, () => {
+  for (let i = 0; i < 256; i++) {
+    console.log(`[38;5;${i}mForeground color ${i.toString().padStart(3, ' ')} bright`);
+  }
+  console.log(`${db}Debug message${rs}`);
+  console.log(`${nf}Info message${rs}`);
+  console.log(`${nt}Notice message${rs}`);
+  console.log(`${wr}Warn message${rs}`);
+  console.log(`${er}Error message${rs}`);
+  console.log(`${ft}Fatal message${rs}`);
+  console.log(`${nf}Stringify payload: ${payloadStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined })}${rs}`);
+  console.log(`${nf}Stringify color: ${colorStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined })}${rs}`);
+  console.log(`${nf}Stringify history: ${historyStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined })}${rs}`);
+  console.log(
+    `${nf}Stringify mqtt: ${mqttStringify({
+      number: 1234,
+      string: 'Text',
+      boolean: true,
+      null: null,
+      undefined: undefined,
+      function: () => {
         //
-    });
-    logger.log("debug" /* LogLevel.DEBUG */, `Debug message with array params: ${rs}\n`, obj, [123, 'abc', { a: 1, b: 2 }], 123, 212121111111111122121n, 'Text', true, null, undefined, () => {
-        //
-    });
-    logger.log("debug" /* LogLevel.DEBUG */, `Debug message without params: ${debugStringify(obj)}`);
+      },
+    })}${rs}`,
+  );
+  console.log(
+    `${db}Stringify debug: ${debugStringify({ number: 1234, string: 'Text', boolean: true, null: null, undefined: undefined, object: { number: 1234, string: 'Text', boolean: true } })}${rs}`,
+  );
+
+  const logger = new AnsiLogger({ logName: 'TestLogger', logLevel: LogLevel.DEBUG, logWithColors: true, logTimestampFormat: TimestampFormat.TIME_MILLIS });
+  logger.logFilePath = 'test-local.log';
+  AnsiLogger.setGlobalLogfile('test-global.log', LogLevel.DEBUG, true);
+  logger.debug('Debug message');
+  logger.info('Info message');
+  logger.notice('Notice message');
+  logger.warn('Warn message');
+  logger.error('Error message');
+  logger.fatal('Fatal message');
+  const obj: object = {
+    logName: 'TestLogger',
+    logLevel: LogLevel.DEBUG,
+    logWithColors: true,
+    logTimestampFormat: TimestampFormat.TIME_MILLIS,
+  };
+  logger.log(LogLevel.DEBUG, `Debug message with params: ${rs}\n`, obj);
+  logger.log(LogLevel.DEBUG, `Debug message with params: ${rs}\n`, obj, 123, 212121111111111122121n, 'Text', true, null, undefined, () => {
+    //
+  });
+  logger.log(LogLevel.DEBUG, `Debug message with array params: ${rs}\n`, obj, [123, 'abc', { a: 1, b: 2 }], 123, 212121111111111122121n, 'Text', true, null, undefined, () => {
+    //
+  });
+  logger.log(LogLevel.DEBUG, `Debug message without params: ${debugStringify(obj)}`);
 }
+*/
 /*
-    \x1b[0m - Reset (clear color)
-    \x1b[1m - Bold
-    \x1b[3m - Italic
-    \x1b[4m - Underline
-    \x1b[K  - Erase the line from cursor
+     - Reset (clear color)
+     - Bold
+     - Italic
+     - Underline
+      - Erase the line from cursor
 
-    \x1b[30m - Black
-    \x1b[31m - Red
-    \x1b[32m - Green
-    \x1b[33m - Yellow
-    \x1b[34m - Blue
-    \x1b[35m - Magenta
-    \x1b[36m - Cyan
-    \x1b[37m - White
+     - Black
+     - Red
+     - Green
+     - Yellow
+     - Blue
+     - Magenta
+     - Cyan
+     - White
 
-    \x1b[90-97m - Bright
+    [90-97m - Bright
 
-    \x1b[40m - Black background
-    \x1b[41m - Red background
-    \x1b[42m - Green background
-    \x1b[43m - Yellow background
-    \x1b[44m - Blue background
-    \x1b[45m - Magenta background
-    \x1b[46m - Cyan background
-    \x1b[47m - White background
+     - Black background
+     - Red background
+     - Green background
+     - Yellow background
+     - Blue background
+     - Magenta background
+     - Cyan background
+     - White background
 
-    \x1b[100-107m - Bright background
+    [100-107m - Bright background
 
-    \x1b[38;2;255;105;50m // Orange
+     // Orange
 
     RGB foreground
-    \x1b[38;2;<R>;<G>;<B>m
+    [38;2;<R>;<G>;<B>m
 
     RGB background
-    \x1b[48;2;<R>;<G>;<B>m
+    [48;2;<R>;<G>;<B>m
 
     256 colors foreground
-    \x1b[38;5;<FG COLOR>m
+    [38;5;<FG COLOR>m
 
     256 colors background
-    \x1b[48;5;<BG COLOR>m
+    [48;5;<BG COLOR>m
 */
 //# sourceMappingURL=logger.js.map