@mks2508/better-logger 2.1.0 → 3.1.0

package/dist/index.js

@@ -1,10 +1,116 @@
-import { L as Logger } from "./chunks/Logger-B7L-ujY4.js";
-import { B, a, T } from "./chunks/Logger-B7L-ujY4.js";
-import { i as isNode, a as isBrowser, S as StylePresets, b as StyleBuilder } from "./chunks/environment-TI2ByCPT.js";
-import { B as B2, D, E, d, f, g, p } from "./chunks/environment-TI2ByCPT.js";
-import { s as safeSerialize } from "./chunks/formatting-CuNUqGks.js";
-import { B as B3, h, i, g as g2, j, f as f2, k, a as a2, b, e, c, d as d2, l, m, n } from "./chunks/formatting-CuNUqGks.js";
+import { L as Logger } from "./chunks/Logger-C086w3EM.js";
+import { A, B, C, d, H, c, S, a, T, b } from "./chunks/Logger-C086w3EM.js";
+import { i as isNode, a as isBrowser, g as getTerminalWidth, b as getANSIForeground, A as ANSI, S as StylePresets, c as StyleBuilder } from "./chunks/environment-DXHouGD4.js";
+import { B as B2, D, E, T as T2, k, o, d as d2, f, n, m, l, u, q, w, e, v, j, h, s, p, r, t } from "./chunks/environment-DXHouGD4.js";
+import { s as safeSerialize } from "./chunks/formatting-BNnVUPcw.js";
+import { B as B3, h as h2, i, g, j as j2, f as f2, k as k2, a as a2, b as b2, e as e2, c as c2, d as d3, l as l2, m as m2, n as n2 } from "./chunks/formatting-BNnVUPcw.js";
 import { R } from "./chunks/RemoteLogHandler-CjWpWZGl.js";
+class ConsoleTransport {
+  constructor(options) {
+    this.options = options;
+  }
+  name = "console";
+  write(record) {
+    const method = this.getConsoleMethod(record.level);
+    const prefix = record.prefix ? `[${record.prefix}] ` : "";
+    const location = record.location ? ` (${record.location.file}:${record.location.line})` : "";
+    console[method](`[${record.level.toUpperCase()}]${prefix} ${record.msg}${location}`);
+  }
+  getConsoleMethod(level) {
+    switch (level) {
+      case "debug":
+        return "log";
+      case "info":
+        return "info";
+      case "warn":
+        return "warn";
+      case "error":
+      case "critical":
+        return "error";
+      default:
+        return "log";
+    }
+  }
+}
+class FileTransport {
+  name = "file";
+  buffer = [];
+  flushTimer;
+  options;
+  constructor(options) {
+    this.options = options || {};
+    if (this.options.flushInterval) {
+      this.flushTimer = setInterval(() => this.flush(), this.options.flushInterval);
+    }
+  }
+  write(record) {
+    const line = JSON.stringify(record) + "\n";
+    this.buffer.push(line);
+    if (this.buffer.length >= (this.options.batchSize || 100)) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0) return;
+    const lines = this.buffer.join("");
+    this.buffer = [];
+    if (typeof globalThis.process !== "undefined" && typeof require === "function") {
+      try {
+        const fs = require("fs");
+        const dest = this.options.destination || "app.log";
+        fs.appendFileSync(dest, lines);
+      } catch {
+      }
+    }
+  }
+  close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flush();
+  }
+}
+class HttpTransport {
+  name = "http";
+  buffer = [];
+  flushTimer;
+  options;
+  constructor(options) {
+    this.options = options || {};
+    if (this.options.flushInterval) {
+      this.flushTimer = setInterval(() => this.flush(), this.options.flushInterval);
+    }
+  }
+  write(record) {
+    this.buffer.push(record);
+    if (this.buffer.length >= (this.options.batchSize || 50)) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.buffer.length === 0 || !this.options.url) return;
+    const records = [...this.buffer];
+    this.buffer = [];
+    try {
+      await fetch(this.options.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...this.options.headers
+        },
+        body: JSON.stringify({ logs: records })
+      });
+    } catch {
+      this.buffer.unshift(...records);
+    }
+  }
+  close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flush();
+  }
+}
 class FileLogHandler {
   filename;
   maxSize;
@@ -148,6 +254,240 @@ class AnalyticsLogHandler {
     }
   }
 }
+const DEFAULT_CONFIG = {
+  maxEntries: 100,
+  ttl: 5 * 60 * 1e3,
+  enabled: true
+};
+class StyleCache {
+  cache = /* @__PURE__ */ new Map();
+  config;
+  hitCount = 0;
+  missCount = 0;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  generateKey(key) {
+    return `${key.level}:${key.theme}:${key.presetName || "default"}:${key.hasPrefix}:${key.hasLocation}`;
+  }
+  get(key) {
+    if (!this.config.enabled) return null;
+    const cacheKey = this.generateKey(key);
+    const entry = this.cache.get(cacheKey);
+    if (!entry) {
+      this.missCount++;
+      return null;
+    }
+    if (Date.now() - entry.createdAt > this.config.ttl) {
+      this.cache.delete(cacheKey);
+      this.missCount++;
+      return null;
+    }
+    entry.hits++;
+    this.cache.delete(cacheKey);
+    this.cache.set(cacheKey, entry);
+    this.hitCount++;
+    return entry;
+  }
+  set(key, format, styles) {
+    if (!this.config.enabled) return;
+    const cacheKey = this.generateKey(key);
+    if (this.cache.size >= this.config.maxEntries) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(cacheKey, {
+      format,
+      styles: [...styles],
+      createdAt: Date.now(),
+      hits: 0
+    });
+  }
+  clear() {
+    this.cache.clear();
+    this.hitCount = 0;
+    this.missCount = 0;
+  }
+  getStats() {
+    const total = this.hitCount + this.missCount;
+    return {
+      size: this.cache.size,
+      maxSize: this.config.maxEntries,
+      hitRate: total > 0 ? this.hitCount / total : 0,
+      hits: this.hitCount,
+      misses: this.missCount
+    };
+  }
+  setEnabled(enabled) {
+    this.config.enabled = enabled;
+    if (!enabled) {
+      this.clear();
+    }
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+}
+let _styleCache = null;
+function getStyleCache() {
+  if (!_styleCache) {
+    _styleCache = new StyleCache();
+  }
+  return _styleCache;
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function getVisibleLength(str) {
+  return stripAnsi(str).length;
+}
+function padToWidth(str, width, align = "left") {
+  const visibleLen = getVisibleLength(str);
+  if (visibleLen >= width) return str;
+  const padding = width - visibleLen;
+  switch (align) {
+    case "right":
+      return " ".repeat(padding) + str;
+    case "center":
+      const leftPad = Math.floor(padding / 2);
+      const rightPad = padding - leftPad;
+      return " ".repeat(leftPad) + str + " ".repeat(rightPad);
+    case "left":
+    default:
+      return str + " ".repeat(padding);
+  }
+}
+function formatWithRightAlign(leftContent, rightContent, maxWidth) {
+  const width = maxWidth ?? getTerminalWidth();
+  const leftLen = getVisibleLength(leftContent);
+  const rightLen = getVisibleLength(rightContent);
+  const gap = width - leftLen - rightLen;
+  if (gap <= 1) {
+    return `${leftContent} ${rightContent}`;
+  }
+  return `${leftContent}${" ".repeat(gap)}${rightContent}`;
+}
+function formatColumns(columns, maxWidth, colorCapability = "full") {
+  const width = maxWidth ?? getTerminalWidth();
+  columns.length;
+  const columnsWithWidths = columns.map((col, idx) => {
+    if (col.width) return { ...col, calculatedWidth: col.width };
+    const remainingWidth = width - columns.filter((c3, i2) => i2 !== idx && c3.width).reduce((sum, c3) => sum + (c3.width ?? 0), 0);
+    const autoColumns = columns.filter((c3) => !c3.width).length;
+    const calculatedWidth = Math.floor(remainingWidth / autoColumns);
+    return { ...col, calculatedWidth };
+  });
+  return columnsWithWidths.map((col) => {
+    let content = col.content;
+    if (col.color && colorCapability !== "none") {
+      const colorCode = getANSIForeground(col.color, colorCapability);
+      content = `${colorCode}${content}${ANSI.reset}`;
+    }
+    return padToWidth(content, col.calculatedWidth, col.align);
+  }).join("");
+}
+function formatKeyValue(obj, colorCapability = "full", options = {}) {
+  const {
+    separator = "  ",
+    keyColor = "#888888",
+    valueColor = "#00ffff"
+  } = options;
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "";
+  const keyColorCode = colorCapability !== "none" ? getANSIForeground(keyColor, colorCapability) : "";
+  const valueColorCode = colorCapability !== "none" ? getANSIForeground(valueColor, colorCapability) : "";
+  const reset = colorCapability !== "none" ? ANSI.reset : "";
+  return entries.map(([key, value]) => {
+    const valueStr = typeof value === "object" ? JSON.stringify(value) : String(value);
+    return `${keyColorCode}${key}:${reset} ${valueColorCode}${valueStr}${reset}`;
+  }).join(separator);
+}
+function isKeyValueObject(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  if (Array.isArray(obj)) return false;
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null) return false;
+  const values = Object.values(obj);
+  return values.every(
+    (v2) => typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean" || v2 === null
+  );
+}
+function formatBadge(badge2, style = "brackets", colorCapability = "full", color) {
+  const colorCode = color && colorCapability !== "none" ? getANSIForeground(color, colorCapability) : "";
+  const reset = colorCapability !== "none" ? ANSI.reset : "";
+  const bgBlack = colorCapability !== "none" ? ANSI.bg.black : "";
+  const text = badge2.toUpperCase();
+  switch (style) {
+    case "rounded":
+      return `${bgBlack}${colorCode}⟨${text}⟩${reset}`;
+    case "plain":
+      return `${colorCode}${text}${reset}`;
+    case "unicode":
+      return `${bgBlack}${colorCode}╭${text}╮${reset}`;
+    case "pill":
+      return `${bgBlack}${colorCode}⦗${text}⦘${reset}`;
+    case "brackets":
+    default:
+      return `${bgBlack}${colorCode}[${text}]${reset}`;
+  }
+}
+function formatTimestamp(date = /* @__PURE__ */ new Date(), format = "time") {
+  switch (format) {
+    case "iso":
+      return date.toISOString();
+    case "date":
+      return date.toISOString().split("T")[0] ?? "";
+    case "time":
+      return date.toTimeString().slice(0, 8);
+    case "timeMs":
+      return date.toTimeString().slice(0, 8) + "." + String(date.getMilliseconds()).padStart(3, "0");
+    case "relative":
+      return formatRelativeTime(date);
+    case "elapsed":
+      return formatElapsedTime(date);
+    case "custom":
+    default:
+      return date.toLocaleTimeString();
+  }
+}
+let startTime = null;
+function formatRelativeTime(date) {
+  if (startTime === null) {
+    startTime = Date.now();
+  }
+  const diff = date.getTime() - startTime;
+  if (diff < 1e3) {
+    return `+${diff}ms`;
+  } else if (diff < 6e4) {
+    return `+${(diff / 1e3).toFixed(1)}s`;
+  } else {
+    const mins = Math.floor(diff / 6e4);
+    const secs = Math.floor(diff % 6e4 / 1e3);
+    return `+${mins}m${secs}s`;
+  }
+}
+function formatElapsedTime(date) {
+  if (startTime === null) {
+    startTime = Date.now();
+  }
+  const diff = date.getTime() - startTime;
+  const hours = Math.floor(diff / 36e5);
+  const mins = Math.floor(diff % 36e5 / 6e4);
+  const secs = Math.floor(diff % 6e4 / 1e3);
+  return `${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}:${String(secs).padStart(2, "0")}`;
+}
+function resetStartTime() {
+  startTime = Date.now();
+}
+function applyLogOptions(message, options, colorCapability = "full") {
+  let result = message;
+  if (options.rightAlign) {
+    result = formatWithRightAlign(message, options.rightAlign);
+  }
+  return result;
+}
 let _logger = null;
 function getLogger() {
   if (!_logger) {
@@ -169,7 +509,12 @@ const groupEnd = () => getLogger().groupEnd();
 const time = (label) => getLogger().time(label);
 const timeEnd = (label) => getLogger().timeEnd(label);
 const setGlobalPrefix = (prefix) => getLogger().setGlobalPrefix(prefix);
-const scope = (prefix) => getLogger().scope(prefix);
+const scope = (name) => getLogger().scope(name);
+const component = (name) => getLogger().component(name);
+const api = (name) => getLogger().api(name);
+const badges = (badgeList) => getLogger().badges(badgeList);
+const badge = (badgeName) => getLogger().badge(badgeName);
+const clearBadges = () => getLogger().clearBadges();
 const setVerbosity = (level) => getLogger().setVerbosity(level);
 const addHandler = (handler) => getLogger().addHandler(handler);
 const setTheme = (theme) => getLogger().setTheme(theme);
@@ -178,6 +523,16 @@ const showBanner = (bannerType) => getLogger().showBanner(bannerType);
 const logWithSVG = (message, svgContent, options) => getLogger().logWithSVG(message, svgContent, options);
 const logAnimated = (message, duration) => getLogger().logAnimated(message, duration);
 const cli = (command) => getLogger().cli(command);
+const addSerializer = (type, serializer, priority) => getLogger().addSerializer(type, serializer, priority);
+const removeSerializer = (type) => getLogger().removeSerializer(type);
+const on = (event, callback, priority) => getLogger().on(event, callback, priority);
+const once = (event, callback, priority) => getLogger().once(event, callback, priority);
+const off = (event, callback) => getLogger().off(event, callback);
+const use = (middleware, priority) => getLogger().use(middleware, priority);
+const addTransport = (target) => getLogger().addTransport(target);
+const removeTransport = (id) => getLogger().removeTransport(id);
+const flushTransports = () => getLogger().flushTransports();
+const closeTransports = () => getLogger().closeTransports();
 const createStyle = () => new StyleBuilder();
 const stylePresets = {
   success: StylePresets.success().build(),
@@ -187,61 +542,119 @@ const stylePresets = {
   accent: StylePresets.accent().build()
 };
 export {
+  ANSI,
+  A as APILogger,
   AnalyticsLogHandler,
   B as BANNER_VARIANTS,
   B3 as BUILD_FORMATTERS,
   B2 as BUILD_PRESETS,
+  C as ComponentLogger,
+  ConsoleTransport,
+  d as ContextLogger,
   D as DEFAULT_CONFIG,
   E as ENVIRONMENT_DETECTION,
   FileLogHandler,
+  FileTransport,
+  H as HookManager,
+  HttpTransport,
   Logger,
   R as RemoteLogHandler,
+  c as ScopedLogger,
+  S as SerializerRegistry,
   StyleBuilder,
+  StyleCache,
   StylePresets,
   a as THEME_BANNERS,
   T as THEME_PRESETS,
+  T2 as TerminalRenderer,
+  b as TransportManager,
   addHandler,
-  h as ansiBackground,
+  addSerializer,
+  addTransport,
+  h2 as ansiBackground,
   i as ansiBold,
-  g2 as ansiColor,
-  j as ansiDim,
+  g as ansiColor,
+  j2 as ansiDim,
   f2 as ansiStyle,
-  k as ansiUnderline,
+  k2 as ansiUnderline,
+  api,
+  applyLogOptions,
+  badge,
+  badges,
+  clearBadges,
   cli,
+  closeTransports,
+  k as colorToHex,
+  component,
   a2 as createANSIOutput,
-  b as createBuildOutput,
-  e as createCIOutput,
-  c as createOutput,
+  b2 as createBuildOutput,
+  e2 as createCIOutput,
+  c2 as createOutput,
   createStyle,
   critical,
+  o as cssColorToANSI,
   debug,
   index as default,
-  d as detectEnvironmentPreset,
-  d2 as detectOptimalFormat,
+  d2 as detectEnvironmentPreset,
+  d3 as detectOptimalFormat,
   error,
-  l as formatLogLevelANSI,
-  m as formatSuccessANSI,
+  flushTransports,
+  formatBadge,
+  formatColumns,
+  formatElapsedTime,
+  formatKeyValue,
+  l2 as formatLogLevelANSI,
+  formatRelativeTime,
+  m2 as formatSuccessANSI,
   f as formatTimestamp,
-  g as getOptimalConfig,
+  formatTimestamp as formatTimestampExt,
+  formatWithRightAlign,
+  n as getANSI256Background,
+  m as getANSI256Foreground,
+  l as getANSIBackground,
+  getANSIForeground,
+  u as getColorCapability,
+  q as getEnvironment,
+  w as getEnvironmentInfo,
+  e as getOptimalConfig,
+  getStyleCache,
+  v as getTerminalHeight,
+  getTerminalWidth,
+  getVisibleLength,
   group,
   groupEnd,
+  j as hexTo256,
+  h as hexToRgb,
   info,
+  isKeyValueObject,
+  s as isRunningInTerminal,
   logAnimated,
   logWithSVG,
+  off,
+  on,
+  once,
+  padToWidth,
   p as parseStackTrace,
-  n as sanitizeEmojis,
+  removeSerializer,
+  removeTransport,
+  resetStartTime,
+  r as rgbToHex,
+  n2 as sanitizeEmojis,
   scope,
   setBannerType,
   setGlobalPrefix,
   setTheme,
   setVerbosity,
   showBanner,
+  stripAnsi,
   stylePresets,
   success,
+  t as supportsANSI,
   table,
   time,
   timeEnd,
   trace,
+  use,
   warn
 };
 //# sourceMappingURL=index.js.map