@mks2508/better-logger 5.0.1 → 5.0.2

package/dist/index.js

@@ -0,0 +1,627 @@
+import { L as Logger } from "./chunks/Logger-D_vuKP4l.js";
+import { A, B, C, e, H, c, S, a, T, b } from "./chunks/Logger-D_vuKP4l.js";
+import { a as isNode, i as isBrowser, S as StylePresets, b as StyleBuilder } from "./chunks/environment-C1xxvc8l.js";
+import { B as B2, D, E, T as T2, e as e2, f, g, p } from "./chunks/environment-C1xxvc8l.js";
+import { A as A2, c as c2, f as f2, e as e3, d, b as b2, g as g2, k, i, n, m, l, a as a2, h, j, r, s } from "./chunks/color-converter-_Xdmsy7E.js";
+import { s as safeSerialize } from "./chunks/formatting-DMJxYq9o.js";
+import { B as B3, l as l2, m as m2, k as k2, n as n2, j as j2, o, e as e4, h as h2, i as i2, c as c3, d as d2, p as p2, q, r as r2 } from "./chunks/formatting-DMJxYq9o.js";
+import { R } from "./chunks/RemoteLogHandler-CjWpWZGl.js";
+import { j as j3, c as c4, a as a3, g as g3, b as b3, e as e5, d as d3, f as f3, h as h3, i as i3, p as p3, r as r3, s as s2 } from "./chunks/cli-module-Cx7qotPY.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;
+  fs;
+  // Node.js fs module
+  constructor(filename = "app.log", maxSize) {
+    this.filename = filename;
+    this.maxSize = maxSize;
+    if (isNode) {
+      try {
+        this.fs = require("fs");
+      } catch (error2) {
+        console.warn("FileLogHandler: Unable to load fs module:", error2);
+      }
+    }
+  }
+  handle(level, message, args, metadata) {
+    const logEntry = {
+      timestamp: metadata.timestamp,
+      level: level.toUpperCase(),
+      prefix: metadata.prefix,
+      message,
+      args: args.slice(1).map((arg) => safeSerialize(arg)),
+      location: metadata.stackInfo
+    };
+    const logLine = this.formatLogLine(logEntry);
+    if (isNode && this.fs) {
+      this.writeToFileNode(logLine);
+    } else if (isBrowser) {
+      this.writeToFileLocal(logLine);
+    } else {
+      console.log(`[FILE-LOG] ${logLine}`);
+    }
+  }
+  /**
+   * Format log entry as a single line for file storage
+   */
+  formatLogLine(entry) {
+    const parts = [
+      entry.timestamp,
+      `[${entry.level}]`,
+      entry.prefix ? `[${entry.prefix}]` : "",
+      entry.message
+    ].filter(Boolean);
+    let line = parts.join(" ");
+    if (entry.args && entry.args.length > 0) {
+      line += " " + entry.args.map(
+        (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+      ).join(" ");
+    }
+    if (entry.location) {
+      line += ` (${entry.location.file}:${entry.location.line}:${entry.location.column})`;
+    }
+    return line;
+  }
+  /**
+   * Write to actual file in Node.js environment
+   */
+  writeToFileNode(logLine) {
+    if (!this.fs) return;
+    try {
+      if (this.maxSize) {
+        try {
+          const stats = this.fs.statSync(this.filename);
+          if (stats.size > this.maxSize) {
+            const backupName = `${this.filename}.bak`;
+            this.fs.renameSync(this.filename, backupName);
+          }
+        } catch (error2) {
+        }
+      }
+      this.fs.appendFileSync(this.filename, logLine + "\n", "utf8");
+    } catch (error2) {
+      console.error("FileLogHandler: Failed to write to file:", error2);
+    }
+  }
+  /**
+   * Write to localStorage in browser environment
+   */
+  writeToFileLocal(logLine) {
+    try {
+      const storageKey = `logger_${this.filename}`;
+      const existingLogs = localStorage.getItem(storageKey) || "";
+      let newLogs = existingLogs;
+      if (existingLogs.length > 0) {
+        newLogs += "\n";
+      }
+      newLogs += logLine;
+      if (this.maxSize || newLogs.split("\n").length > 1e3) {
+        const lines = newLogs.split("\n");
+        const maxLines = this.maxSize ? Math.floor(this.maxSize / 100) : 1e3;
+        if (lines.length > maxLines) {
+          newLogs = lines.slice(-maxLines).join("\n");
+        }
+      }
+      localStorage.setItem(storageKey, newLogs);
+    } catch (error2) {
+      console.error("FileLogHandler: Failed to write to localStorage:", error2);
+    }
+  }
+  /**
+   * Get stored logs (useful for debugging)
+   */
+  getLogs() {
+    if (isNode && this.fs) {
+      try {
+        return this.fs.readFileSync(this.filename, "utf8");
+      } catch (error2) {
+        return null;
+      }
+    } else if (isBrowser) {
+      const storageKey = `logger_${this.filename}`;
+      return localStorage.getItem(storageKey);
+    }
+    return null;
+  }
+  /**
+   * Clear stored logs
+   */
+  clearLogs() {
+    if (isNode && this.fs) {
+      try {
+        this.fs.writeFileSync(this.filename, "", "utf8");
+      } catch (error2) {
+        console.error("FileLogHandler: Failed to clear file:", error2);
+      }
+    } else if (isBrowser) {
+      const storageKey = `logger_${this.filename}`;
+      localStorage.removeItem(storageKey);
+    }
+  }
+}
+class AnalyticsLogHandler {
+  handle(level, message, _args, metadata) {
+    if (level === "error" || level === "critical") {
+      console.debug("Analytics: Error tracked", {
+        level,
+        message,
+        timestamp: metadata.timestamp
+      });
+    }
+  }
+}
+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;
+}
+class BufferWriter {
+  buffer = [];
+  maxSize;
+  /**
+   * Creates a new BufferWriter
+   * @param maxSize - Maximum number of entries to buffer (default: 1000)
+   */
+  constructor(maxSize = 1e3) {
+    this.maxSize = maxSize;
+  }
+  /**
+   * Writes a log entry to the buffer
+   * @param message - Formatted log message
+   * @param level - Log level
+   * @param styles - CSS styles (for browser console)
+   */
+  write(message, level, styles) {
+    if (this.buffer.length >= this.maxSize) {
+      this.buffer.shift();
+    }
+    this.buffer.push({
+      message,
+      level,
+      styles,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Returns all buffered entries
+   * @returns Copy of the buffer array
+   */
+  getBuffer() {
+    return [...this.buffer];
+  }
+  /**
+   * Returns buffered entries filtered by log level
+   * @param levels - Log levels to include
+   * @returns Filtered buffer entries
+   */
+  getByLevel(...levels) {
+    return this.buffer.filter((entry) => levels.includes(entry.level));
+  }
+  /**
+   * Returns the number of buffered entries
+   */
+  get size() {
+    return this.buffer.length;
+  }
+  /**
+   * Checks if buffer is empty
+   */
+  get isEmpty() {
+    return this.buffer.length === 0;
+  }
+  /**
+   * Clears all buffered entries
+   */
+  clear() {
+    this.buffer = [];
+  }
+  /**
+   * Outputs all buffered entries to console and clears the buffer
+   */
+  flush() {
+    this.buffer.forEach((entry) => {
+      if (entry.styles.length > 0) {
+        console.log(entry.message, ...entry.styles);
+      } else {
+        console.log(entry.message);
+      }
+    });
+    this.clear();
+  }
+  /**
+   * Outputs buffered entries to console without clearing
+   */
+  replay() {
+    this.buffer.forEach((entry) => {
+      if (entry.styles.length > 0) {
+        console.log(entry.message, ...entry.styles);
+      } else {
+        console.log(entry.message);
+      }
+    });
+  }
+  /**
+   * Returns all messages as an array of strings
+   */
+  toArray() {
+    return this.buffer.map((entry) => entry.message);
+  }
+  /**
+   * Returns all messages joined as a single string
+   * @param separator - String to join messages with (default: newline)
+   */
+  toString(separator = "\n") {
+    return this.toArray().join(separator);
+  }
+}
+let _logger = null;
+function getLogger() {
+  if (!_logger) {
+    _logger = new Logger();
+  }
+  return _logger;
+}
+const index = getLogger();
+const debug = (...args) => getLogger().debug(...args);
+const info = (...args) => getLogger().info(...args);
+const warn = (...args) => getLogger().warn(...args);
+const error = (...args) => getLogger().error(...args);
+const success = (...args) => getLogger().success(...args);
+const critical = (...args) => getLogger().critical(...args);
+const trace = (...args) => getLogger().trace(...args);
+const table = (data, columns) => getLogger().table(data, columns);
+const group = (label, collapsed) => getLogger().group(label, collapsed);
+const groupEnd = () => getLogger().groupEnd();
+const time = (label) => getLogger().time(label);
+const timeEnd = (label) => getLogger().timeEnd(label);
+const setGlobalPrefix = (prefix) => getLogger().setGlobalPrefix(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);
+const setBannerType = (bannerType) => getLogger().setBannerType(bannerType);
+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 step = (current, total, message) => getLogger().step(current, total, message);
+const spinner = (message) => getLogger().spinner(message);
+const box = (content, options) => getLogger().box(content, options);
+const cliTable = (rows, options) => getLogger().cliTable(rows, options);
+const header = (title, subtitle) => getLogger().header(title, subtitle);
+const divider = () => getLogger().divider();
+const blank = () => getLogger().blank();
+const setCLILevel = (level) => getLogger().setCLILevel(level);
+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(),
+  error: StylePresets.error().build(),
+  warning: StylePresets.warning().build(),
+  info: StylePresets.info().build(),
+  accent: StylePresets.accent().build()
+};
+export {
+  A2 as ANSI,
+  A as APILogger,
+  AnalyticsLogHandler,
+  B as BANNER_VARIANTS,
+  B3 as BUILD_FORMATTERS,
+  B2 as BUILD_PRESETS,
+  BufferWriter,
+  C as ComponentLogger,
+  ConsoleTransport,
+  e 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,
+  addSerializer,
+  addTransport,
+  l2 as ansiBackground,
+  m2 as ansiBold,
+  k2 as ansiColor,
+  n2 as ansiDim,
+  j2 as ansiStyle,
+  o as ansiUnderline,
+  api,
+  j3 as applyLogOptions,
+  badge,
+  badges,
+  blank,
+  box,
+  clearBadges,
+  cli,
+  cliTable,
+  closeTransports,
+  c2 as colorToHex,
+  component,
+  e4 as createANSIOutput,
+  h2 as createBuildOutput,
+  i2 as createCIOutput,
+  c3 as createOutput,
+  createStyle,
+  critical,
+  f2 as cssColorToANSI,
+  debug,
+  index as default,
+  e2 as detectEnvironmentPreset,
+  d2 as detectOptimalFormat,
+  divider,
+  error,
+  flushTransports,
+  c4 as formatBadge,
+  a3 as formatColumns,
+  g3 as formatElapsedTime,
+  b3 as formatKeyValue,
+  p2 as formatLogLevelANSI,
+  e5 as formatRelativeTime,
+  q as formatSuccessANSI,
+  f as formatTimestamp,
+  d3 as formatTimestampExt,
+  f3 as formatWithRightAlign,
+  e3 as getANSI256Background,
+  d as getANSI256Foreground,
+  b2 as getANSIBackground,
+  g2 as getANSIForeground,
+  k as getColorCapability,
+  i as getEnvironment,
+  n as getEnvironmentInfo,
+  g as getOptimalConfig,
+  getStyleCache,
+  m as getTerminalHeight,
+  l as getTerminalWidth,
+  h3 as getVisibleLength,
+  group,
+  groupEnd,
+  header,
+  a2 as hexTo256,
+  h as hexToRgb,
+  info,
+  i3 as isKeyValueObject,
+  j as isRunningInTerminal,
+  logAnimated,
+  logWithSVG,
+  off,
+  on,
+  once,
+  p3 as padToWidth,
+  p as parseStackTrace,
+  removeSerializer,
+  removeTransport,
+  r3 as resetStartTime,
+  r as rgbToHex,
+  r2 as sanitizeEmojis,
+  scope,
+  setBannerType,
+  setCLILevel,
+  setGlobalPrefix,
+  setTheme,
+  setVerbosity,
+  showBanner,
+  spinner,
+  step,
+  s2 as stripAnsi,
+  stylePresets,
+  success,
+  s as supportsANSI,
+  table,
+  time,
+  timeEnd,
+  trace,
+  use,
+  warn
+};
+//# sourceMappingURL=index.js.map