@mks2508/better-logger 2.0.1 → 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import { Logger } from './Logger.js';
+import { Verbosity, ThemeVariant, BannerType, StyleOptions, ILogHandler, SerializerFn, HookEvent, HookCallback, MiddlewareFn, TransportTarget } from './types/index.js';
+import { StyleBuilder } from './styling/index.js';
+/**
+ * Clase principal Logger con conjunto completo de características
+ *
+ * @example
+ * // Importación y uso básico
+ * import { Logger } from '@mks2508/better-logger';
+ *
+ * const logger = new Logger();
+ * logger.preset('cyberpunk');  // Aplicar preset completo
+ * logger.info('¡Hola mundo!');
+ *
+ * @example
+ * // Logger con scope para componentes
+ * const auth = logger.component('Auth');
+ * auth.info('Usuario autenticando...');
+ * auth.success('Login exitoso');
+ *
+ * @example
+ * // Logger para APIs con badges
+ * const api = logger.api('GraphQL');
+ * api.badges(['v2', 'cached']).info('Query ejecutada');
+ *
+ * @since 0.3.0
+ */
+export { Logger };
+/**
+ * Instancia singleton del logger lista para usar
+ * @default
+ *
+ * @example
+ * // Uso directo sin crear instancia
+ * import logger from '@mks2508/better-logger';
+ *
+ * logger.info('Aplicación iniciada');
+ * logger.success('Conexión establecida');
+ * logger.warn('Memoria al 80%');
+ * logger.error('Fallo en conexión');
+ */
+declare const _default: Logger;
+export default _default;
+/**
+ * Métodos de logging individuales (enlazados al singleton)
+ *
+ * @example
+ * // Importar solo los métodos necesarios
+ * import { info, error, success } from '@mks2508/better-logger';
+ *
+ * info('Proceso iniciado');
+ * success('✓ Completado exitosamente');
+ * error('Error:', errorDetails);
+ *
+ * @since 0.3.0
+ */
+export declare const debug: (...args: any[]) => void;
+export declare const info: (...args: any[]) => void;
+export declare const warn: (...args: any[]) => void;
+export declare const error: (...args: any[]) => void;
+export declare const success: (...args: any[]) => void;
+export declare const critical: (...args: any[]) => void;
+export declare const trace: (...args: any[]) => void;
+export declare const table: (data: any, columns?: string[]) => void;
+export declare const group: (label: string, collapsed?: boolean) => void;
+export declare const groupEnd: () => void;
+export declare const time: (label: string) => void;
+export declare const timeEnd: (label: string) => void;
+export declare const setGlobalPrefix: (prefix: string) => void;
+export declare const scope: (name: string) => import('./ScopedLogger.js').ScopedLogger;
+export declare const component: (name: string) => import('./ScopedLogger.js').ComponentLogger;
+export declare const api: (name: string) => import('./ScopedLogger.js').APILogger;
+export declare const badges: (badgeList: string[]) => Logger;
+export declare const badge: (badgeName: string) => Logger;
+export declare const clearBadges: () => Logger;
+export declare const setVerbosity: (level: Verbosity) => void;
+export declare const addHandler: (handler: ILogHandler) => void;
+export declare const setTheme: (theme: ThemeVariant) => void;
+export declare const setBannerType: (bannerType: BannerType) => void;
+export declare const showBanner: (bannerType?: BannerType) => void;
+export declare const logWithSVG: (message: string, svgContent?: string, options?: StyleOptions) => void;
+export declare const logAnimated: (message: string, duration?: number) => void;
+export declare const cli: (command: string) => Promise<void>;
+export type { LogLevel, Verbosity, ThemeVariant, BannerType, StyleOptions, ILogHandler, LoggerConfig, LogMetadata, StackInfo, TimerEntry, TimerResult, OutputFormat, IScopedLogger, IAPILogger, IComponentLogger, Bindings, SerializerFn, SerializerContext, SerializerConfig, ISerializerRegistry, HookLogEntry, HookEvent, HookCallback, MiddlewareFn, IHookManager, TransportRecord, TransportOptions, TransportTarget, ITransport, StyleCacheConfig } from './types/index.js';
+export { StyleBuilder, StylePresets, THEME_PRESETS, THEME_BANNERS, BANNER_VARIANTS } from './styling/index.js';
+export { FileLogHandler, RemoteLogHandler, AnalyticsLogHandler } from './handlers/index.js';
+export { SerializerRegistry } from './serializers/index.js';
+export { HookManager } from './hooks/index.js';
+export { TransportManager, ConsoleTransport, FileTransport, HttpTransport } from './transports/index.js';
+export { StyleCache, getStyleCache } from './styling/StyleCache.js';
+export declare const addSerializer: <T>(type: new (...args: any[]) => T, serializer: SerializerFn<T>, priority?: number) => void;
+export declare const removeSerializer: <T>(type: new (...args: any[]) => T) => boolean;
+export declare const on: (event: HookEvent, callback: HookCallback, priority?: number) => () => void;
+export declare const once: (event: HookEvent, callback: HookCallback, priority?: number) => () => void;
+export declare const off: (event: HookEvent, callback: HookCallback) => boolean;
+export declare const use: (middleware: MiddlewareFn, priority?: number) => () => void;
+export declare const addTransport: (target: TransportTarget) => string;
+export declare const removeTransport: (id: string) => boolean;
+export declare const flushTransports: () => Promise<void>;
+export declare const closeTransports: () => Promise<void>;
+export { ScopedLogger, APILogger, ComponentLogger, ContextLogger } from './ScopedLogger.js';
+export { DEFAULT_CONFIG } from './constants.js';
+export { parseStackTrace, formatTimestamp, detectOptimalFormat, createOutput, createANSIOutput, createBuildOutput, createCIOutput } from './utils/index.js';
+export { ansiStyle, ansiColor, ansiBackground, ansiBold, ansiDim, ansiUnderline, formatLogLevelANSI, formatSuccessANSI, BUILD_FORMATTERS, sanitizeEmojis } from './utils/ansi-colors.js';
+export { BUILD_PRESETS, ENVIRONMENT_DETECTION, detectEnvironmentPreset, getOptimalConfig } from './constants.js';
+/**
+ * Crea una nueva instancia de StyleBuilder para estilos personalizados de consola
+ *
+ * @returns {StyleBuilder} Constructor de estilos encadenable
+ *
+ * @example
+ * const estilo = createStyle()
+ *   .gradient('#667eea', '#764ba2')
+ *   .color('white')
+ *   .padding('8px 16px')
+ *   .rounded('4px')
+ *   .shadow('0 2px 4px rgba(0,0,0,0.2)')
+ *   .build();
+ *
+ * @since 0.3.0
+ */
+export declare const createStyle: () => StyleBuilder;
+/**
+ * Presets de estilo predefinidos para casos de uso comunes
+ *
+ * @constant {Object} stylePresets
+ *
+ * @example
+ * console.log('%cOperación exitosa', stylePresets.success);
+ * console.log('%cAdvertencia', stylePresets.warning);
+ * console.log('%cError crítico', stylePresets.error);
+ * console.log('%cInformación', stylePresets.info);
+ * console.log('%cDestacado', stylePresets.accent);
+ *
+ * @since 0.3.0
+ */
+export declare const stylePresets: {
+    success: string;
+    error: string;
+    warning: string;
+    info: string;
+    accent: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,478 @@
+import { L as Logger } from "./chunks/Logger-C126NTrD.js";
+import { A, B, C, d, H, c, S, a, T, b } from "./chunks/Logger-C126NTrD.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 as d2, 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 as b2, e, c as c2, d as d3, l, m, n } from "./chunks/formatting-CuNUqGks.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;
+}
+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 {
+  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,
+  b as TransportManager,
+  addHandler,
+  addSerializer,
+  addTransport,
+  h as ansiBackground,
+  i as ansiBold,
+  g2 as ansiColor,
+  j as ansiDim,
+  f2 as ansiStyle,
+  k as ansiUnderline,
+  api,
+  badge,
+  badges,
+  clearBadges,
+  cli,
+  closeTransports,
+  component,
+  a2 as createANSIOutput,
+  b2 as createBuildOutput,
+  e as createCIOutput,
+  c2 as createOutput,
+  createStyle,
+  critical,
+  debug,
+  index as default,
+  d2 as detectEnvironmentPreset,
+  d3 as detectOptimalFormat,
+  error,
+  flushTransports,
+  l as formatLogLevelANSI,
+  m as formatSuccessANSI,
+  f as formatTimestamp,
+  g as getOptimalConfig,
+  getStyleCache,
+  group,
+  groupEnd,
+  info,
+  logAnimated,
+  logWithSVG,
+  off,
+  on,
+  once,
+  p as parseStackTrace,
+  removeSerializer,
+  removeTransport,
+  n as sanitizeEmojis,
+  scope,
+  setBannerType,
+  setGlobalPrefix,
+  setTheme,
+  setVerbosity,
+  showBanner,
+  stylePresets,
+  success,
+  table,
+  time,
+  timeEnd,
+  trace,
+  use,
+  warn
+};
+//# sourceMappingURL=index.js.map