@feizk/logger 1.7.0 → 2.0.1

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,223 +15,357 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  LEVEL_LABELS: () => LEVEL_LABELS,
+  LOG_LEVEL_PRIORITIES: () => LOG_LEVEL_PRIORITIES,
   Logger: () => Logger,
-  TIMESTAMP_TYPES: () => TIMESTAMP_TYPES
+  buildMessage: () => buildMessage,
+  formatJson: () => formatJson,
+  formatTimestamp: () => formatTimestamp,
+  getColoredLabel: () => getColoredLabel
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/utils.ts
-var import_chalk = __toESM(require("chalk"));
-var TIMESTAMP_TYPES = {
-  ISO: "iso",
-  Locale: "locale",
-  Custom: "custom"
+// src/constants.ts
+var LOG_LEVEL_PRIORITIES = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  fatal: 5
+};
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m",
+  bgRed: "\x1B[41m"
+};
+var LEVEL_COLORS = {
+  trace: ANSI.gray,
+  debug: ANSI.cyan,
+  info: ANSI.blue,
+  warn: ANSI.yellow,
+  error: ANSI.red,
+  fatal: `${ANSI.bgRed}${ANSI.white}${ANSI.bold}`
+};
+var LEVEL_LABELS = {
+  trace: "[TRACE]",
+  debug: "[DEBUG]",
+  info: "[INFO]",
+  warn: "[WARN]",
+  error: "[ERROR]",
+  fatal: "[FATAL]"
 };
-function formatTimestamp(formatTimestampFn, types, date = /* @__PURE__ */ new Date()) {
-  const [, timestamp] = formatTimestampFn(types, date);
-  return timestamp;
+var CONSOLE_METHODS = {
+  trace: "trace",
+  debug: "debug",
+  info: "log",
+  warn: "warn",
+  error: "error",
+  fatal: "error"
+};
+var TIMESTAMP_PRESETS = {
+  iso: (date) => date.toISOString(),
+  locale: (date) => date.toLocaleString()
+};
+
+// src/utils.ts
+var coloredLabelCache = /* @__PURE__ */ new Map();
+function getColoredLabel(level, enableColors) {
+  const cacheKey = `${level}:${enableColors}`;
+  const cached = coloredLabelCache.get(cacheKey);
+  if (cached !== void 0) return cached;
+  const label = LEVEL_LABELS[level];
+  if (!enableColors) {
+    coloredLabelCache.set(cacheKey, label);
+    return label;
+  }
+  const color = LEVEL_COLORS[level];
+  const result = `${color}${label}${ANSI.reset}`;
+  coloredLabelCache.set(cacheKey, result);
+  return result;
 }
-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 formatTimestamp(option, date = /* @__PURE__ */ new Date()) {
+  if (typeof option === "function") {
+    return option(date);
+  }
+  const preset = TIMESTAMP_PRESETS[option];
+  return preset(date);
 }
-function getDiscordColor(level) {
-  const colors = {
-    debug: 9807270,
-    info: 3447003,
-    warn: 15965202,
-    error: 15158332
+function formatJson(entry) {
+  const message = entry.args.map(formatArg).join(" ");
+  const output = {
+    level: entry.level,
+    timestamp: entry.timestamp,
+    message
   };
-  return colors[level];
-}
-function generateId() {
-  return Math.random().toString(36).substr(2, 8).toUpperCase();
+  if (entry.prefix) {
+    output.prefix = entry.prefix;
+  }
+  if (Object.keys(entry.context).length > 0) {
+    output.context = entry.context;
+  }
+  return JSON.stringify(output);
 }
-function formatLog(level, timestamp, args, options) {
-  const { formatLog: formatLog2, enableColors = true } = options;
-  const coloredLevel = getColor(level, enableColors);
-  if (formatLog2) {
-    return [formatLog2(coloredLevel, timestamp, args)];
+function formatArg(arg) {
+  if (arg === null) return "null";
+  if (arg === void 0) return "undefined";
+  if (typeof arg === "string") return arg;
+  if (typeof arg === "number") return String(arg);
+  if (typeof arg === "boolean") return String(arg);
+  if (typeof arg === "bigint") return `${arg}n`;
+  if (typeof arg === "symbol") return arg.toString();
+  if (arg instanceof Error) {
+    const parts = [arg.message];
+    if (arg.name && arg.name !== "Error") parts.unshift(arg.name);
+    if (arg.stack) parts.push(arg.stack);
+    return parts.join(": ");
+  }
+  if (Array.isArray(arg)) {
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }
+  try {
+    return JSON.stringify(arg, getCircularReplacer());
+  } catch {
+    return String(arg);
   }
-  return [`${coloredLevel} ${timestamp}`, ...args];
+}
+function getCircularReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+}
+function buildMessage(args) {
+  return args.map(formatArg).join(" ");
 }
 
 // src/logger.ts
-var defaultFormatTimestamp = (types, date = /* @__PURE__ */ new Date()) => [types.ISO, date.toISOString()];
-var LOG_LEVEL_PRIORITIES = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3
-};
-var Logger = class {
+var Logger = class _Logger {
+  /**
+   * Create a new Logger instance.
+   * @param options - Configuration options
+   */
   constructor(options = {}) {
-    this.discordQueue = [];
-    this.isProcessing = false;
     this.options = {
+      level: options.level ?? "debug",
+      silent: options.silent ?? false,
       enableColors: options.enableColors ?? true,
-      formatTimestamp: options.formatTimestamp ?? defaultFormatTimestamp,
-      formatLog: options.formatLog,
-      discord: options.discord
+      timestamp: options.timestamp ?? "iso",
+      formatter: options.formatter,
+      json: options.json ?? false,
+      transports: [...options.transports ?? []],
+      prefix: options.prefix,
+      context: { ...options.context ?? {} }
     };
-    this.level = options.level ?? "debug";
+    this.transports = this.options.transports;
+    this.prefix = this.options.prefix;
+    this.context = this.options.context;
+  }
+  /**
+   * Log a trace message (most verbose).
+   * @param args - Arguments to log
+   */
+  trace(...args) {
+    this.log("trace", args);
+  }
+  /**
+   * Log a debug message.
+   * @param args - Arguments to log
+   */
+  debug(...args) {
+    this.log("debug", args);
   }
   /**
-   * Sets the minimum log level for filtering messages.
-   * @param level - The log level to set.
+   * Log an info message.
+   * @param args - Arguments to log
+   */
+  info(...args) {
+    this.log("info", args);
+  }
+  /**
+   * Log a warning message.
+   * @param args - Arguments to log
+   */
+  warn(...args) {
+    this.log("warn", args);
+  }
+  /**
+   * Log an error message.
+   * @param args - Arguments to log
+   */
+  error(...args) {
+    this.log("error", args);
+  }
+  /**
+   * Log a fatal message (most severe).
+   * @param args - Arguments to log
+   */
+  fatal(...args) {
+    this.log("fatal", args);
+  }
+  /**
+   * Set the minimum log level.
+   * @param level - The log level to set
    */
   setLevel(level) {
-    this.level = level;
+    this.options.level = level;
   }
   /**
-   * Sends a log message to Discord via webhook if configured.
-   * @param level - The log level.
-   * @param timestamp - The formatted timestamp.
-   * @param args - The log arguments.
+   * Get the current log level.
+   * @returns The current log level
    */
-  sendToDiscord(level, timestamp, args) {
-    const discord = this.options.discord;
-    if (!discord?.enable) return;
-    try {
-      new URL(discord.webhookURL);
-    } catch {
-      return;
-    }
-    const message = args.map((arg) => typeof arg === "string" ? arg : JSON.stringify(arg)).join(" ");
-    const title = `${level.toUpperCase()}-${generateId()}`;
-    const embed = discord.formatEmbed ? discord.formatEmbed(level, timestamp, message) : {
-      title,
-      description: message,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      color: getDiscordColor(level)
-    };
-    this.discordQueue.push({ embed, retryCount: 0 });
-    if (!this.isProcessing) {
-      this.isProcessing = true;
-      setTimeout(() => this.processQueue(), 0);
-    }
+  getLevel() {
+    return this.options.level;
   }
   /**
-   * Processes the Discord queue by sending batches of embeds.
+   * Add a transport to the logger.
+   * @param transport - The transport to add
    */
-  processQueue() {
-    if (this.discordQueue.length === 0) {
-      this.isProcessing = false;
-      return;
+  addTransport(transport) {
+    this.transports.push(transport);
+  }
+  /**
+   * Remove a transport from the logger.
+   * @param transport - The transport to remove
+   */
+  removeTransport(transport) {
+    const index = this.transports.indexOf(transport);
+    if (index !== -1) {
+      this.transports.splice(index, 1);
     }
-    this.isProcessing = true;
-    const discord = this.options.discord;
-    const batchSize = discord.batchSize ?? 10;
-    const batch = this.discordQueue.splice(0, batchSize);
-    this.sendBatch(batch.map((item) => item.embed)).then(() => {
-      const delay = discord.batchDelay ?? 2e3;
-      this.processTimeout = setTimeout(() => this.processQueue(), delay);
-    }).catch(() => {
-      const maxRetries = discord.maxRetries ?? 3;
-      const retryItems = batch.filter((item) => item.retryCount < maxRetries).map((item) => ({
-        ...item,
-        retryCount: item.retryCount + 1
-      }));
-      this.discordQueue.unshift(...retryItems);
-      const retryDelayBase = discord.retryDelayBase ?? 1e3;
-      const delay = retryDelayBase * Math.pow(2, batch[0]?.retryCount ?? 0);
-      this.processTimeout = setTimeout(() => this.processQueue(), delay);
-    });
   }
   /**
-   * Sends a batch of embeds to Discord.
-   * @param embeds - The embeds to send.
+   * Create a child logger with additional prefix and context.
+   * @param options - Child logger options
+   * @returns A new Logger instance
    */
-  async sendBatch(embeds) {
-    const discord = this.options.discord;
-    await fetch(discord.webhookURL, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ embeds })
+  child(options = {}) {
+    const combinedPrefix = options.prefix ? this.prefix ? `${this.prefix}:${options.prefix}` : options.prefix : this.prefix;
+    const combinedContext = {
+      ...this.context,
+      ...options.context ?? {}
+    };
+    return new _Logger({
+      level: options.level ?? this.options.level,
+      silent: options.silent ?? this.options.silent,
+      enableColors: this.options.enableColors,
+      timestamp: this.options.timestamp,
+      formatter: this.options.formatter,
+      json: this.options.json,
+      transports: this.transports.slice(),
+      prefix: combinedPrefix,
+      context: combinedContext
     });
   }
   /**
-   * 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.
+   * Destroy the logger and all its transports.
+   * Calls destroy() on all registered transports.
    */
-  shouldLog(level) {
-    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.level];
+  async destroy() {
+    const destroyPromises = this.transports.map(async (transport) => {
+      if (typeof transport.destroy === "function") {
+        await transport.destroy();
+      }
+    });
+    await Promise.all(destroyPromises);
+    this.transports.length = 0;
   }
   /**
-   * Logs an info message.
-   * @param args - The arguments to log.
+   * Core logging method - all public methods delegate here.
+   * @param level - The log level
+   * @param args - The arguments to log
    */
-  info(...args) {
-    if (!this.shouldLog("info")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[INFO]", timestamp, args, this.options));
-    this.sendToDiscord("info", timestamp, args);
+  log(level, args) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      level,
+      timestamp: formatTimestamp(this.options.timestamp),
+      args,
+      prefix: this.prefix,
+      context: this.context
+    };
+    if (!this.options.silent) {
+      this.writeToConsole(level, entry);
+    }
+    for (const transport of this.transports) {
+      this.dispatchToTransport(transport, entry);
+    }
   }
   /**
-   * Logs a warning message.
-   * @param args - The arguments to log.
+   * Write a log entry to the console.
+   * @param level - The log level
+   * @param entry - The log entry
    */
-  warn(...args) {
-    if (!this.shouldLog("warn")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[WARN]", timestamp, args, this.options));
-    this.sendToDiscord("warn", timestamp, args);
+  writeToConsole(level, entry) {
+    const method = CONSOLE_METHODS[level];
+    if (this.options.formatter) {
+      console[method](this.options.formatter(entry));
+      return;
+    }
+    if (this.options.json) {
+      console[method](formatJson(entry));
+      return;
+    }
+    const label = getColoredLabel(entry.level, this.options.enableColors);
+    const prefixStr = entry.prefix ? ` [${entry.prefix}]` : "";
+    const message = buildMessage(entry.args);
+    console[method](`${label} ${entry.timestamp}${prefixStr}`, message);
   }
   /**
-   * Logs an error message.
-   * @param args - The arguments to log.
+   * Dispatch a log entry to a transport.
+   * @param transport - The transport
+   * @param entry - The log entry
    */
-  error(...args) {
-    if (!this.shouldLog("error")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[ERROR]", timestamp, args, this.options));
-    this.sendToDiscord("error", timestamp, args);
+  dispatchToTransport(transport, entry) {
+    try {
+      const result = transport.log(entry);
+      if (result instanceof Promise) {
+        result.catch(() => {
+        });
+      }
+    } catch {
+    }
   }
   /**
-   * Logs a debug message.
-   * @param args - The arguments to log.
+   * Check if a log level should be output.
+   * @param level - The log level to check
+   * @returns True if the message should be logged
    */
-  debug(...args) {
-    if (!this.shouldLog("debug")) return;
-    const timestamp = formatTimestamp(
-      this.options.formatTimestamp,
-      TIMESTAMP_TYPES
-    );
-    console.log(...formatLog("[DEBUG]", timestamp, args, this.options));
-    this.sendToDiscord("debug", timestamp, args);
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITIES[level] >= LOG_LEVEL_PRIORITIES[this.options.level];
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  LEVEL_LABELS,
+  LOG_LEVEL_PRIORITIES,
   Logger,
-  TIMESTAMP_TYPES
+  buildMessage,
+  formatJson,
+  formatTimestamp,
+  getColoredLabel
 });