@mks2508/better-logger 4.0.0 → 5.0.1

package/dist/index.js

@@ -1,609 +0,0 @@
-import { L as Logger } from "./chunks/Logger-D-gmmgR2.js";
-import { A, B, C, d, H, c, S, a, T, b, n, h, e, k, g, j, i, f, m, l, p, r, s } from "./chunks/Logger-D-gmmgR2.js";
-import { i as isNode, a as isBrowser, S as StylePresets, b as StyleBuilder } from "./chunks/environment-COWvu6Wz.js";
-import { A as A2, B as B2, D, E, T as T2, e as e2, n as n2, d as d2, f as f2, m as m2, l as l2, k as k2, j as j2, t, o, w, g as g2, v, u, c as c2, h as h2, q, p as p2, r as r2, s as s2 } from "./chunks/environment-COWvu6Wz.js";
-import { s as safeSerialize } from "./chunks/formatting-CYjT9yhO.js";
-import { B as B3, h as h3, i as i2, g as g3, j as j3, f as f3, k as k3, a as a2, b as b2, e as e3, c as c3, d as d3, l as l3, m as m3, n as n3 } from "./chunks/formatting-CYjT9yhO.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;
-  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 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,
-  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,
-  addSerializer,
-  addTransport,
-  h3 as ansiBackground,
-  i2 as ansiBold,
-  g3 as ansiColor,
-  j3 as ansiDim,
-  f3 as ansiStyle,
-  k3 as ansiUnderline,
-  api,
-  n as applyLogOptions,
-  badge,
-  badges,
-  clearBadges,
-  cli,
-  closeTransports,
-  e2 as colorToHex,
-  component,
-  a2 as createANSIOutput,
-  b2 as createBuildOutput,
-  e3 as createCIOutput,
-  c3 as createOutput,
-  createStyle,
-  critical,
-  n2 as cssColorToANSI,
-  debug,
-  index as default,
-  d2 as detectEnvironmentPreset,
-  d3 as detectOptimalFormat,
-  error,
-  flushTransports,
-  h as formatBadge,
-  e as formatColumns,
-  k as formatElapsedTime,
-  g as formatKeyValue,
-  l3 as formatLogLevelANSI,
-  j as formatRelativeTime,
-  m3 as formatSuccessANSI,
-  f2 as formatTimestamp,
-  i as formatTimestampExt,
-  f as formatWithRightAlign,
-  m2 as getANSI256Background,
-  l2 as getANSI256Foreground,
-  k2 as getANSIBackground,
-  j2 as getANSIForeground,
-  t as getColorCapability,
-  o as getEnvironment,
-  w as getEnvironmentInfo,
-  g2 as getOptimalConfig,
-  getStyleCache,
-  v as getTerminalHeight,
-  u as getTerminalWidth,
-  m as getVisibleLength,
-  group,
-  groupEnd,
-  c2 as hexTo256,
-  h2 as hexToRgb,
-  info,
-  l as isKeyValueObject,
-  q as isRunningInTerminal,
-  logAnimated,
-  logWithSVG,
-  off,
-  on,
-  once,
-  p as padToWidth,
-  p2 as parseStackTrace,
-  removeSerializer,
-  removeTransport,
-  r as resetStartTime,
-  r2 as rgbToHex,
-  n3 as sanitizeEmojis,
-  scope,
-  setBannerType,
-  setGlobalPrefix,
-  setTheme,
-  setVerbosity,
-  showBanner,
-  s as stripAnsi,
-  stylePresets,
-  success,
-  s2 as supportsANSI,
-  table,
-  time,
-  timeEnd,
-  trace,
-  use,
-  warn
-};
-//# sourceMappingURL=index.js.map