@feizk/logger 1.0.0 → 1.4.0

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# @feizk/logger
+
+## 1.4.0
+
+### Minor Changes
+
+- 2b7b1eb: - Added `LogLevel` type ('debug' | 'info' | 'warn' | 'error') and `logLevel` option to `LoggerOptions` in `types.ts`
+  - Updated `logger.ts` to implement log level filtering with a `LOG_LEVEL_PRIORITIES` constant, `shouldLog` private method, and checks before each log call
+  - Added `setLogLevel` method to `logger.ts` for dynamic runtime level changes
+  - Exported `LogLevel` type from `index.ts` for external use
+  - Added comprehensive test cases in `logger.test.ts` for filtering behavior at different levels, dynamic level changes, and default behavior
+  - Updated `README.md` with `logLevel` option documentation, usage examples, and API details for the new method
+
+## 1.3.0
+
+### Minor Changes
+
+- 6e3d7e5: - Created `src/types.ts` with `LoggerOptions` interface for `enableColors`, `timestampFormat`, and `logFormat` options\n- Created `src/utils.ts` with utility functions: `formatTimestamp`, `getColor`, and `formatLog`\n- Moved `Logger` class to `src/logger.ts` and made it configurable via constructor options with defaults\n- Updated `src/index.ts` to export `Logger` class and `LoggerOptions` type instead of containing the class\n- Removed the `success` method from `Logger` class (per user feedback)\n- Removed `[SUCCESS]` color mapping from `utils.ts`\n- Added tests in `tests/logger.test.ts` for disabling colors, locale timestamp, custom timestamp function, and custom log format\n- Removed success-related test from `tests/logger.test.ts`\n- Updated `README.md` with usage examples for new options and removed success method documentation\n- Ensured backward compatibility: existing `new Logger()` usage remains unchanged\n- All tests pass (10 tests) and build succeeds
+
+## 1.2.0
+
+### Minor Changes
+
+- 4b70f01: Accept multiple arguments and Any type of arguments on all Logger methods
+
+## 1.1.0
+
+### Minor Changes
+
+- ebc4e0b: Add success logging method to Logger class

package/README.md

@@ -21,13 +21,45 @@ logger.error('This is an error');
 logger.debug('This is a debug message');
 ```
 
+### Options
+
+Customize the logger with constructor options:
+
+```typescript
+const logger = new Logger({
+  enableColors: true,        // Default: true
+  timestampFormat: 'iso',    // 'iso' | 'locale' | custom function, Default: 'iso'
+  logFormat: undefined,      // Custom formatter function, Default: undefined
+  logLevel: 'debug',         // 'debug' | 'info' | 'warn' | 'error', Default: 'debug'
+});
+```
+
+#### Examples
+
+```typescript
+// Disable colors
+const noColorLogger = new Logger({ enableColors: false });
+
+// Use locale timestamp
+const localeLogger = new Logger({ timestampFormat: 'locale' });
+
+// Filter logs below info level
+const infoLogger = new Logger({ logLevel: 'info' });
+infoLogger.debug('Not logged');
+infoLogger.info('Logged'); // and higher
+
+// Change level dynamically
+logger.setLogLevel('error');
+```
+
 ## API
 
 ### Logger
 
-- `info(message: string)`: Logs an info message.
-- `warn(message: string)`: Logs a warning message.
-- `error(message: string)`: Logs an error message.
-- `debug(message: string)`: Logs a debug message.
+- `info(...args: unknown[])`: Logs an info message.
+- `warn(...args: unknown[])`: Logs a warning message.
+- `error(...args: unknown[])`: Logs an error message.
+- `debug(...args: unknown[])`: Logs a debug message.
+- `setLogLevel(level: LogLevel)`: Sets the minimum log level for filtering messages.
 
-All messages include a timestamp and are colored accordingly.
+All messages include a timestamp and are colored accordingly (unless disabled via options).

package/dist/index.d.mts

@@ -1,29 +1,49 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerOptions {
+    enableColors?: boolean;
+    timestampFormat?: 'iso' | 'locale' | ((date: Date) => string);
+    logFormat?: (level: string, timestamp: string, args: unknown[]) => string;
+    logLevel?: LogLevel;
+}
+
 /**
  * A simple logger with colored outputs and timestamps.
  */
 declare class Logger {
+    private options;
+    private logLevel;
+    constructor(options?: LoggerOptions);
+    /**
+     * Sets the minimum log level for filtering messages.
+     * @param level - The log level to set.
+     */
+    setLogLevel(level: LogLevel): void;
+    /**
+     * Checks if a log level should be output based on the current log level.
+     * @param level - The log level to check.
+     * @returns True if the message should be logged.
+     */
+    private shouldLog;
     /**
      * Logs an info message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    info(message: string): void;
+    info(...args: unknown[]): void;
     /**
      * Logs a warning message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    warn(message: string): void;
+    warn(...args: unknown[]): void;
     /**
      * Logs an error message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    error(message: string): void;
+    error(...args: unknown[]): void;
     /**
      * Logs a debug message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    debug(message: string): void;
-    private getTimestamp;
-    private removeFunction;
+    debug(...args: unknown[]): void;
 }
 
-export { Logger };
+export { type LogLevel, Logger, type LoggerOptions };

package/dist/index.d.ts

@@ -1,29 +1,49 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerOptions {
+    enableColors?: boolean;
+    timestampFormat?: 'iso' | 'locale' | ((date: Date) => string);
+    logFormat?: (level: string, timestamp: string, args: unknown[]) => string;
+    logLevel?: LogLevel;
+}
+
 /**
  * A simple logger with colored outputs and timestamps.
  */
 declare class Logger {
+    private options;
+    private logLevel;
+    constructor(options?: LoggerOptions);
+    /**
+     * Sets the minimum log level for filtering messages.
+     * @param level - The log level to set.
+     */
+    setLogLevel(level: LogLevel): void;
+    /**
+     * Checks if a log level should be output based on the current log level.
+     * @param level - The log level to check.
+     * @returns True if the message should be logged.
+     */
+    private shouldLog;
     /**
      * Logs an info message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    info(message: string): void;
+    info(...args: unknown[]): void;
     /**
      * Logs a warning message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    warn(message: string): void;
+    warn(...args: unknown[]): void;
     /**
      * Logs an error message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    error(message: string): void;
+    error(...args: unknown[]): void;
     /**
      * Logs a debug message.
-     * @param message - The message to log.
+     * @param args - The arguments to log.
      */
-    debug(message: string): void;
-    private getTimestamp;
-    private removeFunction;
+    debug(...args: unknown[]): void;
 }
 
-export { Logger };
+export { type LogLevel, Logger, type LoggerOptions };

package/dist/index.js

@@ -33,41 +33,107 @@ __export(index_exports, {
   Logger: () => Logger
 });
 module.exports = __toCommonJS(index_exports);
+
+// src/utils.ts
 var import_chalk = __toESM(require("chalk"));
+function formatTimestamp(options, date = /* @__PURE__ */ new Date()) {
+  const { timestampFormat = "iso" } = options;
+  if (typeof timestampFormat === "function") {
+    return timestampFormat(date);
+  }
+  switch (timestampFormat) {
+    case "locale":
+      return date.toLocaleString();
+    case "iso":
+    default:
+      return date.toISOString();
+  }
+}
+function getColor(level, enableColors) {
+  if (!enableColors) return level;
+  const colors = {
+    "[INFO]": import_chalk.default.blue(level),
+    "[WARN]": import_chalk.default.yellow(level),
+    "[ERROR]": import_chalk.default.red(level),
+    "[DEBUG]": import_chalk.default.gray(level)
+  };
+  return colors[level] || level;
+}
+function formatLog(level, timestamp, args, options) {
+  const { logFormat, enableColors = true } = options;
+  const coloredLevel = getColor(level, enableColors);
+  if (logFormat) {
+    return [logFormat(coloredLevel, timestamp, args)];
+  }
+  return [`${coloredLevel} ${timestamp}`, ...args];
+}
+
+// src/logger.ts
+var LOG_LEVEL_PRIORITIES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
 var Logger = class {
+  constructor(options = {}) {
+    this.options = {
+      enableColors: options.enableColors ?? true,
+      timestampFormat: options.timestampFormat ?? "iso",
+      logFormat: options.logFormat
+    };
+    this.logLevel = options.logLevel ?? "debug";
+  }
+  /**
+   * Sets the minimum log level for filtering messages.
+   * @param level - The log level to set.
+   */
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  /**
+   * Checks if a log level should be output based on the current log level.
+   * @param level - The log level to check.
+   * @returns True if the message should be logged.
+   */
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.logLevel];
+  }
   /**
    * Logs an info message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  info(message) {
-    console.log(`${import_chalk.default.blue("[INFO]")} ${this.getTimestamp()} ${message}`);
+  info(...args) {
+    if (!this.shouldLog("info")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[INFO]", timestamp, args, this.options));
   }
   /**
    * Logs a warning message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  warn(message) {
-    console.log(`${import_chalk.default.yellow("[WARN]")} ${this.getTimestamp()} ${message}`);
+  warn(...args) {
+    if (!this.shouldLog("warn")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[WARN]", timestamp, args, this.options));
   }
   /**
    * Logs an error message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  error(message) {
-    console.log(`${import_chalk.default.red("[ERROR]")} ${this.getTimestamp()} ${message}`);
+  error(...args) {
+    if (!this.shouldLog("error")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[ERROR]", timestamp, args, this.options));
   }
   /**
    * Logs a debug message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  debug(message) {
-    console.log(`${import_chalk.default.gray("[DEBUG]")} ${this.getTimestamp()} ${message}`);
-  }
-  getTimestamp() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  removeFunction() {
-    return "Please remove this function";
+  debug(...args) {
+    if (!this.shouldLog("debug")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[DEBUG]", timestamp, args, this.options));
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import chalk from 'chalk';\n\n/**\n * A simple logger with colored outputs and timestamps.\n */\nexport class Logger {\n  /**\n   * Logs an info message.\n   * @param message - The message to log.\n   */\n  info(message: string): void {\n    console.log(`${chalk.blue('[INFO]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  /**\n   * Logs a warning message.\n   * @param message - The message to log.\n   */\n  warn(message: string): void {\n    console.log(`${chalk.yellow('[WARN]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  /**\n   * Logs an error message.\n   * @param message - The message to log.\n   */\n  error(message: string): void {\n    console.log(`${chalk.red('[ERROR]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  /**\n   * Logs a debug message.\n   * @param message - The message to log.\n   */\n  debug(message: string): void {\n    console.log(`${chalk.gray('[DEBUG]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  private getTimestamp(): string {\n    return new Date().toISOString();\n  }\n\n  private removeFunction() {\n    return 'Please remove this function';\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAkB;AAKX,IAAM,SAAN,MAAa;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlB,KAAK,SAAuB;AAC1B,YAAQ,IAAI,GAAG,aAAAA,QAAM,KAAK,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,KAAK,SAAuB;AAC1B,YAAQ,IAAI,GAAG,aAAAA,QAAM,OAAO,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,SAAuB;AAC3B,YAAQ,IAAI,GAAG,aAAAA,QAAM,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,SAAuB;AAC3B,YAAQ,IAAI,GAAG,aAAAA,QAAM,KAAK,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EAC1E;AAAA,EAEQ,eAAuB;AAC7B,YAAO,oBAAI,KAAK,GAAE,YAAY;AAAA,EAChC;AAAA,EAEQ,iBAAiB;AACvB,WAAO;AAAA,EACT;AACF;","names":["chalk"]}
+{"version":3,"sources":["../src/index.ts","../src/utils.ts","../src/logger.ts"],"sourcesContent":["export { Logger } from './logger';\nexport type { LoggerOptions, LogLevel } from './types';\n","import chalk from 'chalk';\nimport type { LoggerOptions } from './types';\n\nexport function formatTimestamp(\n  options: LoggerOptions,\n  date: Date = new Date(),\n): string {\n  const { timestampFormat = 'iso' } = options;\n  if (typeof timestampFormat === 'function') {\n    return timestampFormat(date);\n  }\n  switch (timestampFormat) {\n    case 'locale':\n      return date.toLocaleString();\n    case 'iso':\n    default:\n      return date.toISOString();\n  }\n}\n\nexport function getColor(level: string, enableColors: boolean): string {\n  if (!enableColors) return level;\n  const colors: Record<string, string> = {\n    '[INFO]': chalk.blue(level),\n    '[WARN]': chalk.yellow(level),\n    '[ERROR]': chalk.red(level),\n    '[DEBUG]': chalk.gray(level),\n  };\n  return colors[level] || level;\n}\n\nexport function formatLog(\n  level: string,\n  timestamp: string,\n  args: unknown[],\n  options: LoggerOptions,\n): [string, ...unknown[]] {\n  const { logFormat, enableColors = true } = options;\n  const coloredLevel = getColor(level, enableColors);\n  if (logFormat) {\n    return [logFormat(coloredLevel, timestamp, args)];\n  }\n  return [`${coloredLevel} ${timestamp}`, ...args];\n}\n","import type { LoggerOptions, LogLevel } from './types';\nimport { formatTimestamp, formatLog } from './utils';\n\nconst LOG_LEVEL_PRIORITIES: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n/**\n * A simple logger with colored outputs and timestamps.\n */\nexport class Logger {\n  private options: LoggerOptions;\n  private logLevel: LogLevel;\n\n  constructor(options: LoggerOptions = {}) {\n    this.options = {\n      enableColors: options.enableColors ?? true,\n      timestampFormat: options.timestampFormat ?? 'iso',\n      logFormat: options.logFormat,\n    };\n    this.logLevel = options.logLevel ?? 'debug';\n  }\n\n  /**\n   * Sets the minimum log level for filtering messages.\n   * @param level - The log level to set.\n   */\n  setLogLevel(level: LogLevel): void {\n    this.logLevel = level;\n  }\n\n  /**\n   * Checks if a log level should be output based on the current log level.\n   * @param level - The log level to check.\n   * @returns True if the message should be logged.\n   */\n  private shouldLog(level: LogLevel): boolean {\n    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.logLevel];\n  }\n\n  /**\n   * Logs an info message.\n   * @param args - The arguments to log.\n   */\n  info(...args: unknown[]): void {\n    if (!this.shouldLog('info')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[INFO]', timestamp, args, this.options));\n  }\n\n  /**\n   * Logs a warning message.\n   * @param args - The arguments to log.\n   */\n  warn(...args: unknown[]): void {\n    if (!this.shouldLog('warn')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[WARN]', timestamp, args, this.options));\n  }\n\n  /**\n   * Logs an error message.\n   * @param args - The arguments to log.\n   */\n  error(...args: unknown[]): void {\n    if (!this.shouldLog('error')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[ERROR]', timestamp, args, this.options));\n  }\n\n  /**\n   * Logs a debug message.\n   * @param args - The arguments to log.\n   */\n  debug(...args: unknown[]): void {\n    if (!this.shouldLog('debug')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[DEBUG]', timestamp, args, this.options));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,mBAAkB;AAGX,SAAS,gBACd,SACA,OAAa,oBAAI,KAAK,GACd;AACR,QAAM,EAAE,kBAAkB,MAAM,IAAI;AACpC,MAAI,OAAO,oBAAoB,YAAY;AACzC,WAAO,gBAAgB,IAAI;AAAA,EAC7B;AACA,UAAQ,iBAAiB;AAAA,IACvB,KAAK;AACH,aAAO,KAAK,eAAe;AAAA,IAC7B,KAAK;AAAA,IACL;AACE,aAAO,KAAK,YAAY;AAAA,EAC5B;AACF;AAEO,SAAS,SAAS,OAAe,cAA+B;AACrE,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,SAAiC;AAAA,IACrC,UAAU,aAAAA,QAAM,KAAK,KAAK;AAAA,IAC1B,UAAU,aAAAA,QAAM,OAAO,KAAK;AAAA,IAC5B,WAAW,aAAAA,QAAM,IAAI,KAAK;AAAA,IAC1B,WAAW,aAAAA,QAAM,KAAK,KAAK;AAAA,EAC7B;AACA,SAAO,OAAO,KAAK,KAAK;AAC1B;AAEO,SAAS,UACd,OACA,WACA,MACA,SACwB;AACxB,QAAM,EAAE,WAAW,eAAe,KAAK,IAAI;AAC3C,QAAM,eAAe,SAAS,OAAO,YAAY;AACjD,MAAI,WAAW;AACb,WAAO,CAAC,UAAU,cAAc,WAAW,IAAI,CAAC;AAAA,EAClD;AACA,SAAO,CAAC,GAAG,YAAY,IAAI,SAAS,IAAI,GAAG,IAAI;AACjD;;;ACxCA,IAAM,uBAAiD;AAAA,EACrD,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AAKO,IAAM,SAAN,MAAa;AAAA,EAIlB,YAAY,UAAyB,CAAC,GAAG;AACvC,SAAK,UAAU;AAAA,MACb,cAAc,QAAQ,gBAAgB;AAAA,MACtC,iBAAiB,QAAQ,mBAAmB;AAAA,MAC5C,WAAW,QAAQ;AAAA,IACrB;AACA,SAAK,WAAW,QAAQ,YAAY;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAY,OAAuB;AACjC,SAAK,WAAW;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,UAAU,OAA0B;AAC1C,WAAO,qBAAqB,KAAK,KAAK,qBAAqB,KAAK,QAAQ;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,MAAuB;AAC7B,QAAI,CAAC,KAAK,UAAU,MAAM,EAAG;AAC7B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,UAAU,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,MAAuB;AAC7B,QAAI,CAAC,KAAK,UAAU,MAAM,EAAG;AAC7B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,UAAU,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,MAAuB;AAC9B,QAAI,CAAC,KAAK,UAAU,OAAO,EAAG;AAC9B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,WAAW,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,MAAuB;AAC9B,QAAI,CAAC,KAAK,UAAU,OAAO,EAAG;AAC9B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,WAAW,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACpE;AACF;","names":["chalk"]}

package/dist/index.mjs

@@ -1,39 +1,103 @@
-// src/index.ts
+// src/utils.ts
 import chalk from "chalk";
+function formatTimestamp(options, date = /* @__PURE__ */ new Date()) {
+  const { timestampFormat = "iso" } = options;
+  if (typeof timestampFormat === "function") {
+    return timestampFormat(date);
+  }
+  switch (timestampFormat) {
+    case "locale":
+      return date.toLocaleString();
+    case "iso":
+    default:
+      return date.toISOString();
+  }
+}
+function getColor(level, enableColors) {
+  if (!enableColors) return level;
+  const colors = {
+    "[INFO]": chalk.blue(level),
+    "[WARN]": chalk.yellow(level),
+    "[ERROR]": chalk.red(level),
+    "[DEBUG]": chalk.gray(level)
+  };
+  return colors[level] || level;
+}
+function formatLog(level, timestamp, args, options) {
+  const { logFormat, enableColors = true } = options;
+  const coloredLevel = getColor(level, enableColors);
+  if (logFormat) {
+    return [logFormat(coloredLevel, timestamp, args)];
+  }
+  return [`${coloredLevel} ${timestamp}`, ...args];
+}
+
+// src/logger.ts
+var LOG_LEVEL_PRIORITIES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
 var Logger = class {
+  constructor(options = {}) {
+    this.options = {
+      enableColors: options.enableColors ?? true,
+      timestampFormat: options.timestampFormat ?? "iso",
+      logFormat: options.logFormat
+    };
+    this.logLevel = options.logLevel ?? "debug";
+  }
+  /**
+   * Sets the minimum log level for filtering messages.
+   * @param level - The log level to set.
+   */
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  /**
+   * Checks if a log level should be output based on the current log level.
+   * @param level - The log level to check.
+   * @returns True if the message should be logged.
+   */
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.logLevel];
+  }
   /**
    * Logs an info message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  info(message) {
-    console.log(`${chalk.blue("[INFO]")} ${this.getTimestamp()} ${message}`);
+  info(...args) {
+    if (!this.shouldLog("info")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[INFO]", timestamp, args, this.options));
   }
   /**
    * Logs a warning message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  warn(message) {
-    console.log(`${chalk.yellow("[WARN]")} ${this.getTimestamp()} ${message}`);
+  warn(...args) {
+    if (!this.shouldLog("warn")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[WARN]", timestamp, args, this.options));
   }
   /**
    * Logs an error message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  error(message) {
-    console.log(`${chalk.red("[ERROR]")} ${this.getTimestamp()} ${message}`);
+  error(...args) {
+    if (!this.shouldLog("error")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[ERROR]", timestamp, args, this.options));
   }
   /**
    * Logs a debug message.
-   * @param message - The message to log.
+   * @param args - The arguments to log.
    */
-  debug(message) {
-    console.log(`${chalk.gray("[DEBUG]")} ${this.getTimestamp()} ${message}`);
-  }
-  getTimestamp() {
-    return (/* @__PURE__ */ new Date()).toISOString();
-  }
-  removeFunction() {
-    return "Please remove this function";
+  debug(...args) {
+    if (!this.shouldLog("debug")) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog("[DEBUG]", timestamp, args, this.options));
   }
 };
 export {

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import chalk from 'chalk';\n\n/**\n * A simple logger with colored outputs and timestamps.\n */\nexport class Logger {\n  /**\n   * Logs an info message.\n   * @param message - The message to log.\n   */\n  info(message: string): void {\n    console.log(`${chalk.blue('[INFO]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  /**\n   * Logs a warning message.\n   * @param message - The message to log.\n   */\n  warn(message: string): void {\n    console.log(`${chalk.yellow('[WARN]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  /**\n   * Logs an error message.\n   * @param message - The message to log.\n   */\n  error(message: string): void {\n    console.log(`${chalk.red('[ERROR]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  /**\n   * Logs a debug message.\n   * @param message - The message to log.\n   */\n  debug(message: string): void {\n    console.log(`${chalk.gray('[DEBUG]')} ${this.getTimestamp()} ${message}`);\n  }\n\n  private getTimestamp(): string {\n    return new Date().toISOString();\n  }\n\n  private removeFunction() {\n    return 'Please remove this function';\n  }\n}\n"],"mappings":";AAAA,OAAO,WAAW;AAKX,IAAM,SAAN,MAAa;AAAA;AAAA;AAAA;AAAA;AAAA,EAKlB,KAAK,SAAuB;AAC1B,YAAQ,IAAI,GAAG,MAAM,KAAK,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,KAAK,SAAuB;AAC1B,YAAQ,IAAI,GAAG,MAAM,OAAO,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,SAAuB;AAC3B,YAAQ,IAAI,GAAG,MAAM,IAAI,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,SAAuB;AAC3B,YAAQ,IAAI,GAAG,MAAM,KAAK,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,IAAI,OAAO,EAAE;AAAA,EAC1E;AAAA,EAEQ,eAAuB;AAC7B,YAAO,oBAAI,KAAK,GAAE,YAAY;AAAA,EAChC;AAAA,EAEQ,iBAAiB;AACvB,WAAO;AAAA,EACT;AACF;","names":[]}
+{"version":3,"sources":["../src/utils.ts","../src/logger.ts"],"sourcesContent":["import chalk from 'chalk';\nimport type { LoggerOptions } from './types';\n\nexport function formatTimestamp(\n  options: LoggerOptions,\n  date: Date = new Date(),\n): string {\n  const { timestampFormat = 'iso' } = options;\n  if (typeof timestampFormat === 'function') {\n    return timestampFormat(date);\n  }\n  switch (timestampFormat) {\n    case 'locale':\n      return date.toLocaleString();\n    case 'iso':\n    default:\n      return date.toISOString();\n  }\n}\n\nexport function getColor(level: string, enableColors: boolean): string {\n  if (!enableColors) return level;\n  const colors: Record<string, string> = {\n    '[INFO]': chalk.blue(level),\n    '[WARN]': chalk.yellow(level),\n    '[ERROR]': chalk.red(level),\n    '[DEBUG]': chalk.gray(level),\n  };\n  return colors[level] || level;\n}\n\nexport function formatLog(\n  level: string,\n  timestamp: string,\n  args: unknown[],\n  options: LoggerOptions,\n): [string, ...unknown[]] {\n  const { logFormat, enableColors = true } = options;\n  const coloredLevel = getColor(level, enableColors);\n  if (logFormat) {\n    return [logFormat(coloredLevel, timestamp, args)];\n  }\n  return [`${coloredLevel} ${timestamp}`, ...args];\n}\n","import type { LoggerOptions, LogLevel } from './types';\nimport { formatTimestamp, formatLog } from './utils';\n\nconst LOG_LEVEL_PRIORITIES: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\n/**\n * A simple logger with colored outputs and timestamps.\n */\nexport class Logger {\n  private options: LoggerOptions;\n  private logLevel: LogLevel;\n\n  constructor(options: LoggerOptions = {}) {\n    this.options = {\n      enableColors: options.enableColors ?? true,\n      timestampFormat: options.timestampFormat ?? 'iso',\n      logFormat: options.logFormat,\n    };\n    this.logLevel = options.logLevel ?? 'debug';\n  }\n\n  /**\n   * Sets the minimum log level for filtering messages.\n   * @param level - The log level to set.\n   */\n  setLogLevel(level: LogLevel): void {\n    this.logLevel = level;\n  }\n\n  /**\n   * Checks if a log level should be output based on the current log level.\n   * @param level - The log level to check.\n   * @returns True if the message should be logged.\n   */\n  private shouldLog(level: LogLevel): boolean {\n    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.logLevel];\n  }\n\n  /**\n   * Logs an info message.\n   * @param args - The arguments to log.\n   */\n  info(...args: unknown[]): void {\n    if (!this.shouldLog('info')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[INFO]', timestamp, args, this.options));\n  }\n\n  /**\n   * Logs a warning message.\n   * @param args - The arguments to log.\n   */\n  warn(...args: unknown[]): void {\n    if (!this.shouldLog('warn')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[WARN]', timestamp, args, this.options));\n  }\n\n  /**\n   * Logs an error message.\n   * @param args - The arguments to log.\n   */\n  error(...args: unknown[]): void {\n    if (!this.shouldLog('error')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[ERROR]', timestamp, args, this.options));\n  }\n\n  /**\n   * Logs a debug message.\n   * @param args - The arguments to log.\n   */\n  debug(...args: unknown[]): void {\n    if (!this.shouldLog('debug')) return;\n    const timestamp = formatTimestamp(this.options);\n    console.log(...formatLog('[DEBUG]', timestamp, args, this.options));\n  }\n}\n"],"mappings":";AAAA,OAAO,WAAW;AAGX,SAAS,gBACd,SACA,OAAa,oBAAI,KAAK,GACd;AACR,QAAM,EAAE,kBAAkB,MAAM,IAAI;AACpC,MAAI,OAAO,oBAAoB,YAAY;AACzC,WAAO,gBAAgB,IAAI;AAAA,EAC7B;AACA,UAAQ,iBAAiB;AAAA,IACvB,KAAK;AACH,aAAO,KAAK,eAAe;AAAA,IAC7B,KAAK;AAAA,IACL;AACE,aAAO,KAAK,YAAY;AAAA,EAC5B;AACF;AAEO,SAAS,SAAS,OAAe,cAA+B;AACrE,MAAI,CAAC,aAAc,QAAO;AAC1B,QAAM,SAAiC;AAAA,IACrC,UAAU,MAAM,KAAK,KAAK;AAAA,IAC1B,UAAU,MAAM,OAAO,KAAK;AAAA,IAC5B,WAAW,MAAM,IAAI,KAAK;AAAA,IAC1B,WAAW,MAAM,KAAK,KAAK;AAAA,EAC7B;AACA,SAAO,OAAO,KAAK,KAAK;AAC1B;AAEO,SAAS,UACd,OACA,WACA,MACA,SACwB;AACxB,QAAM,EAAE,WAAW,eAAe,KAAK,IAAI;AAC3C,QAAM,eAAe,SAAS,OAAO,YAAY;AACjD,MAAI,WAAW;AACb,WAAO,CAAC,UAAU,cAAc,WAAW,IAAI,CAAC;AAAA,EAClD;AACA,SAAO,CAAC,GAAG,YAAY,IAAI,SAAS,IAAI,GAAG,IAAI;AACjD;;;ACxCA,IAAM,uBAAiD;AAAA,EACrD,OAAO;AAAA,EACP,MAAM;AAAA,EACN,MAAM;AAAA,EACN,OAAO;AACT;AAKO,IAAM,SAAN,MAAa;AAAA,EAIlB,YAAY,UAAyB,CAAC,GAAG;AACvC,SAAK,UAAU;AAAA,MACb,cAAc,QAAQ,gBAAgB;AAAA,MACtC,iBAAiB,QAAQ,mBAAmB;AAAA,MAC5C,WAAW,QAAQ;AAAA,IACrB;AACA,SAAK,WAAW,QAAQ,YAAY;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,YAAY,OAAuB;AACjC,SAAK,WAAW;AAAA,EAClB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,UAAU,OAA0B;AAC1C,WAAO,qBAAqB,KAAK,KAAK,qBAAqB,KAAK,QAAQ;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,MAAuB;AAC7B,QAAI,CAAC,KAAK,UAAU,MAAM,EAAG;AAC7B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,UAAU,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,QAAQ,MAAuB;AAC7B,QAAI,CAAC,KAAK,UAAU,MAAM,EAAG;AAC7B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,UAAU,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,MAAuB;AAC9B,QAAI,CAAC,KAAK,UAAU,OAAO,EAAG;AAC9B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,WAAW,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,SAAS,MAAuB;AAC9B,QAAI,CAAC,KAAK,UAAU,OAAO,EAAG;AAC9B,UAAM,YAAY,gBAAgB,KAAK,OAAO;AAC9C,YAAQ,IAAI,GAAG,UAAU,WAAW,WAAW,MAAM,KAAK,OAAO,CAAC;AAAA,EACpE;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@feizk/logger",
-  "version": "1.0.0",
+  "version": "1.4.0",
   "description": "A simple logger package with colored outputs and timestamps",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,46 +1,2 @@
-import chalk from 'chalk';
-
-/**
- * A simple logger with colored outputs and timestamps.
- */
-export class Logger {
-  /**
-   * Logs an info message.
-   * @param message - The message to log.
-   */
-  info(message: string): void {
-    console.log(`${chalk.blue('[INFO]')} ${this.getTimestamp()} ${message}`);
-  }
-
-  /**
-   * Logs a warning message.
-   * @param message - The message to log.
-   */
-  warn(message: string): void {
-    console.log(`${chalk.yellow('[WARN]')} ${this.getTimestamp()} ${message}`);
-  }
-
-  /**
-   * Logs an error message.
-   * @param message - The message to log.
-   */
-  error(message: string): void {
-    console.log(`${chalk.red('[ERROR]')} ${this.getTimestamp()} ${message}`);
-  }
-
-  /**
-   * Logs a debug message.
-   * @param message - The message to log.
-   */
-  debug(message: string): void {
-    console.log(`${chalk.gray('[DEBUG]')} ${this.getTimestamp()} ${message}`);
-  }
-
-  private getTimestamp(): string {
-    return new Date().toISOString();
-  }
-
-  private removeFunction() {
-    return 'Please remove this function';
-  }
-}
+export { Logger } from './logger';
+export type { LoggerOptions, LogLevel } from './types';

package/src/logger.ts

@@ -0,0 +1,83 @@
+import type { LoggerOptions, LogLevel } from './types';
+import { formatTimestamp, formatLog } from './utils';
+
+const LOG_LEVEL_PRIORITIES: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+/**
+ * A simple logger with colored outputs and timestamps.
+ */
+export class Logger {
+  private options: LoggerOptions;
+  private logLevel: LogLevel;
+
+  constructor(options: LoggerOptions = {}) {
+    this.options = {
+      enableColors: options.enableColors ?? true,
+      timestampFormat: options.timestampFormat ?? 'iso',
+      logFormat: options.logFormat,
+    };
+    this.logLevel = options.logLevel ?? 'debug';
+  }
+
+  /**
+   * Sets the minimum log level for filtering messages.
+   * @param level - The log level to set.
+   */
+  setLogLevel(level: LogLevel): void {
+    this.logLevel = level;
+  }
+
+  /**
+   * Checks if a log level should be output based on the current log level.
+   * @param level - The log level to check.
+   * @returns True if the message should be logged.
+   */
+  private shouldLog(level: LogLevel): boolean {
+    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.logLevel];
+  }
+
+  /**
+   * Logs an info message.
+   * @param args - The arguments to log.
+   */
+  info(...args: unknown[]): void {
+    if (!this.shouldLog('info')) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog('[INFO]', timestamp, args, this.options));
+  }
+
+  /**
+   * Logs a warning message.
+   * @param args - The arguments to log.
+   */
+  warn(...args: unknown[]): void {
+    if (!this.shouldLog('warn')) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog('[WARN]', timestamp, args, this.options));
+  }
+
+  /**
+   * Logs an error message.
+   * @param args - The arguments to log.
+   */
+  error(...args: unknown[]): void {
+    if (!this.shouldLog('error')) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog('[ERROR]', timestamp, args, this.options));
+  }
+
+  /**
+   * Logs a debug message.
+   * @param args - The arguments to log.
+   */
+  debug(...args: unknown[]): void {
+    if (!this.shouldLog('debug')) return;
+    const timestamp = formatTimestamp(this.options);
+    console.log(...formatLog('[DEBUG]', timestamp, args, this.options));
+  }
+}

package/src/types.ts

@@ -0,0 +1,8 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export interface LoggerOptions {
+  enableColors?: boolean;
+  timestampFormat?: 'iso' | 'locale' | ((date: Date) => string);
+  logFormat?: (level: string, timestamp: string, args: unknown[]) => string;
+  logLevel?: LogLevel;
+}

package/src/utils.ts

@@ -0,0 +1,44 @@
+import chalk from 'chalk';
+import type { LoggerOptions } from './types';
+
+export function formatTimestamp(
+  options: LoggerOptions,
+  date: Date = new Date(),
+): string {
+  const { timestampFormat = 'iso' } = options;
+  if (typeof timestampFormat === 'function') {
+    return timestampFormat(date);
+  }
+  switch (timestampFormat) {
+    case 'locale':
+      return date.toLocaleString();
+    case 'iso':
+    default:
+      return date.toISOString();
+  }
+}
+
+export function getColor(level: string, enableColors: boolean): string {
+  if (!enableColors) return level;
+  const colors: Record<string, string> = {
+    '[INFO]': chalk.blue(level),
+    '[WARN]': chalk.yellow(level),
+    '[ERROR]': chalk.red(level),
+    '[DEBUG]': chalk.gray(level),
+  };
+  return colors[level] || level;
+}
+
+export function formatLog(
+  level: string,
+  timestamp: string,
+  args: unknown[],
+  options: LoggerOptions,
+): [string, ...unknown[]] {
+  const { logFormat, enableColors = true } = options;
+  const coloredLevel = getColor(level, enableColors);
+  if (logFormat) {
+    return [logFormat(coloredLevel, timestamp, args)];
+  }
+  return [`${coloredLevel} ${timestamp}`, ...args];
+}

package/tests/logger.test.ts

@@ -27,33 +27,33 @@ describe('Logger', () => {
 
   it('should have info method', () => {
     logger.info('test message');
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[INFO]'));
     expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('test message'),
+      expect.stringContaining('[INFO]'),
+      'test message',
     );
   });
 
   it('should have warn method', () => {
     logger.warn('test message');
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[WARN]'));
     expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('test message'),
+      expect.stringContaining('[WARN]'),
+      'test message',
     );
   });
 
   it('should have error method', () => {
     logger.error('test message');
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[ERROR]'));
     expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('test message'),
+      expect.stringContaining('[ERROR]'),
+      'test message',
     );
   });
 
   it('should have debug method', () => {
     logger.debug('test message');
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[DEBUG]'));
     expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('test message'),
+      expect.stringContaining('[DEBUG]'),
+      'test message',
     );
   });
 
@@ -62,4 +62,119 @@ describe('Logger', () => {
     const callArgs = consoleSpy.mock.calls[0][0];
     expect(callArgs).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z/);
   });
+
+  it('should handle multiple arguments', () => {
+    logger.info('hello', 'world', 42, { key: 'value' });
+    const calls = consoleSpy.mock.calls[0];
+    expect(calls[0]).toMatch(/\[INFO\]/);
+    expect(calls[1]).toBe('hello');
+    expect(calls[2]).toBe('world');
+    expect(calls[3]).toBe(42);
+    expect(calls[4]).toEqual({ key: 'value' });
+  });
+
+  it('should disable colors when enableColors is false', () => {
+    const noColorLogger = new Logger({ enableColors: false });
+    noColorLogger.info('test message');
+    const callArgs = consoleSpy.mock.calls[0][0];
+    expect(callArgs).toContain('[INFO]'); // Should not have ANSI codes
+    expect(callArgs).not.toContain('\u001b['); // ANSI escape code
+  });
+
+  it('should use locale timestamp format', () => {
+    const localeLogger = new Logger({ timestampFormat: 'locale' });
+    localeLogger.info('test');
+    const callArgs = consoleSpy.mock.calls[0][0];
+    expect(callArgs).toMatch(/\d{1,2}\/\d{1,2}\/\d{4}/); // Basic locale date check
+  });
+
+  it('should use custom timestamp function', () => {
+    const customLogger = new Logger({
+      timestampFormat: () => 'custom-time',
+    });
+    customLogger.info('test');
+    const callArgs = consoleSpy.mock.calls[0][0];
+    expect(callArgs).toContain('custom-time');
+  });
+
+  it('should use custom log format', () => {
+    const customLogger = new Logger({
+      logFormat: (level, timestamp, args) =>
+        `${timestamp} ${level}: ${args.join(' ')}`,
+    });
+    customLogger.warn('hello', 'world');
+    const callArgs = consoleSpy.mock.calls[0][0];
+    expect(callArgs).toMatch(
+      /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z \[WARN\]: hello world/,
+    );
+  });
+
+  it('should default to debug log level', () => {
+    const defaultLogger = new Logger();
+    defaultLogger.debug('debug message');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[DEBUG]'),
+      'debug message',
+    );
+  });
+
+  it('should filter logs below the set level', () => {
+    const infoLogger = new Logger({ logLevel: 'info' });
+    infoLogger.debug('debug message');
+    expect(consoleSpy).not.toHaveBeenCalled();
+
+    infoLogger.info('info message');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[INFO]'),
+      'info message',
+    );
+  });
+
+  it('should allow all levels when set to debug', () => {
+    const debugLogger = new Logger({ logLevel: 'debug' });
+    debugLogger.debug('debug');
+    debugLogger.info('info');
+    debugLogger.warn('warn');
+    debugLogger.error('error');
+    expect(consoleSpy).toHaveBeenCalledTimes(4);
+  });
+
+  it('should filter debug and info when set to warn', () => {
+    const warnLogger = new Logger({ logLevel: 'warn' });
+    warnLogger.debug('debug');
+    warnLogger.info('info');
+    expect(consoleSpy).not.toHaveBeenCalled();
+
+    warnLogger.warn('warn');
+    warnLogger.error('error');
+    expect(consoleSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it('should only log errors when set to error', () => {
+    const errorLogger = new Logger({ logLevel: 'error' });
+    errorLogger.debug('debug');
+    errorLogger.info('info');
+    errorLogger.warn('warn');
+    expect(consoleSpy).not.toHaveBeenCalled();
+
+    errorLogger.error('error');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[ERROR]'),
+      'error',
+    );
+  });
+
+  it('should allow changing log level dynamically', () => {
+    const logger = new Logger();
+    logger.setLogLevel('error');
+    logger.debug('debug');
+    expect(consoleSpy).not.toHaveBeenCalled();
+
+    logger.setLogLevel('debug');
+    logger.debug('debug');
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('[DEBUG]'),
+      'debug',
+    );
+  });
 });