@talex-touch/utils 1.0.40 → 1.0.44

package/common/logger/logger-manager.ts

@@ -0,0 +1,303 @@
+/**
+ * LoggerManager
+ *
+ * Singleton manager for all module loggers.
+ * Handles configuration, global controls, and logger lifecycle.
+ */
+
+import type { LoggerInfo, LoggingConfig, ModuleLoggerOptions } from './types'
+import { ModuleLogger } from './module-logger'
+import {
+
+  LogLevel,
+  logLevelToString,
+
+  stringToLogLevel,
+} from './types'
+
+/**
+ * Default logging configuration
+ */
+const DEFAULT_CONFIG: LoggingConfig = {
+  enabled: true,
+  globalLevel: 'debug',
+  modules: {},
+}
+
+/**
+ * Predefined module defaults
+ */
+const MODULE_DEFAULTS: Record<string, { enabled: boolean, level: LogLevel, color: string }> = {
+  'search-engine': { enabled: true, level: LogLevel.DEBUG, color: 'cyan' },
+  'file-provider': { enabled: false, level: LogLevel.DEBUG, color: 'green' },
+  'app-provider': { enabled: false, level: LogLevel.DEBUG, color: 'blue' },
+  'plugin-system': { enabled: true, level: LogLevel.INFO, color: 'magenta' },
+  'database': { enabled: false, level: LogLevel.WARN, color: 'yellow' },
+  'storage': { enabled: false, level: LogLevel.WARN, color: 'yellow' },
+  'clipboard': { enabled: false, level: LogLevel.INFO, color: 'cyan' },
+  'flow-bus': { enabled: true, level: LogLevel.INFO, color: 'green' },
+  'division-box': { enabled: true, level: LogLevel.INFO, color: 'blue' },
+  'channel-core': { enabled: true, level: LogLevel.INFO, color: 'cyan' },
+  'core-box': { enabled: true, level: LogLevel.INFO, color: 'cyan' },
+  'tray': { enabled: false, level: LogLevel.INFO, color: 'gray' },
+  'download': { enabled: true, level: LogLevel.INFO, color: 'green' },
+  'intelligence': { enabled: true, level: LogLevel.INFO, color: 'magenta' },
+  'terminal': { enabled: false, level: LogLevel.DEBUG, color: 'gray' },
+  'update': { enabled: true, level: LogLevel.INFO, color: 'blue' },
+  'widget': { enabled: true, level: LogLevel.DEBUG, color: 'cyan' },
+}
+
+/**
+ * LoggerManager singleton
+ *
+ * Manages all module loggers with:
+ * - Centralized configuration
+ * - Global enable/disable
+ * - Per-module level control
+ * - Configuration persistence
+ */
+export class LoggerManager {
+  private static instance: LoggerManager | null = null
+  private loggers: Map<string, ModuleLogger> = new Map()
+  private config: LoggingConfig = { ...DEFAULT_CONFIG }
+  private configLoader: (() => Promise<LoggingConfig | null>) | null = null
+  private configSaver: ((config: LoggingConfig) => Promise<void>) | null = null
+
+  private constructor() {}
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): LoggerManager {
+    if (!LoggerManager.instance) {
+      LoggerManager.instance = new LoggerManager()
+    }
+    return LoggerManager.instance
+  }
+
+  /**
+   * Get or create a logger for a module
+   */
+  getLogger(module: string, options?: Partial<ModuleLoggerOptions>): ModuleLogger {
+    let logger = this.loggers.get(module)
+
+    if (!logger) {
+      // Get module defaults
+      const defaults = MODULE_DEFAULTS[module]
+      const moduleConfig = this.config.modules[module]
+
+      // Determine enabled state
+      let enabled = this.config.enabled
+      if (moduleConfig?.enabled !== undefined) {
+        enabled = enabled && moduleConfig.enabled
+      }
+      else if (defaults?.enabled !== undefined) {
+        enabled = enabled && defaults.enabled
+      }
+      if (options?.enabled !== undefined) {
+        enabled = enabled && options.enabled
+      }
+
+      // Determine log level
+      let level = stringToLogLevel(this.config.globalLevel)
+      if (moduleConfig?.level) {
+        level = Math.max(level, stringToLogLevel(moduleConfig.level))
+      }
+      else if (defaults?.level !== undefined) {
+        level = Math.max(level, defaults.level)
+      }
+      if (options?.level !== undefined) {
+        level = options.level
+      }
+
+      // Determine color
+      const color = options?.color ?? defaults?.color ?? 'cyan'
+
+      logger = new ModuleLogger({
+        module,
+        color,
+        enabled,
+        level,
+        prefix: options?.prefix,
+      })
+
+      this.loggers.set(module, logger)
+    }
+
+    return logger
+  }
+
+  /**
+   * Enable all loggers
+   */
+  enableAll(): void {
+    this.config.enabled = true
+    for (const logger of this.loggers.values()) {
+      logger.setEnabled(true)
+    }
+  }
+
+  /**
+   * Disable all loggers
+   */
+  disableAll(): void {
+    this.config.enabled = false
+    for (const logger of this.loggers.values()) {
+      logger.setEnabled(false)
+    }
+  }
+
+  /**
+   * Set global log level
+   */
+  setGlobalLevel(level: LogLevel): void {
+    this.config.globalLevel = logLevelToString(level)
+    for (const logger of this.loggers.values()) {
+      if (logger.getLevel() < level) {
+        logger.setLevel(level)
+      }
+    }
+  }
+
+  /**
+   * Set module-specific configuration
+   */
+  setModuleConfig(module: string, enabled: boolean, level: LogLevel): void {
+    this.config.modules[module] = {
+      enabled,
+      level: logLevelToString(level),
+    }
+
+    const logger = this.loggers.get(module)
+    if (logger) {
+      logger.setEnabled(this.config.enabled && enabled)
+      logger.setLevel(level)
+    }
+  }
+
+  /**
+   * List all registered loggers
+   */
+  listLoggers(): LoggerInfo[] {
+    return Array.from(this.loggers.entries()).map(([module, logger]) => ({
+      module,
+      enabled: logger.isEnabled(),
+      level: logger.getLevel(),
+      color: logger.getColor(),
+    }))
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): LoggingConfig {
+    return { ...this.config }
+  }
+
+  /**
+   * Set configuration
+   */
+  setConfig(config: Partial<LoggingConfig>): void {
+    this.config = { ...this.config, ...config }
+    this.applyConfig()
+  }
+
+  /**
+   * Set config loader function
+   */
+  setConfigLoader(loader: () => Promise<LoggingConfig | null>): void {
+    this.configLoader = loader
+  }
+
+  /**
+   * Set config saver function
+   */
+  setConfigSaver(saver: (config: LoggingConfig) => Promise<void>): void {
+    this.configSaver = saver
+  }
+
+  /**
+   * Load configuration from storage
+   */
+  async loadConfig(): Promise<void> {
+    if (!this.configLoader)
+      return
+
+    try {
+      const loaded = await this.configLoader()
+      if (loaded) {
+        this.config = { ...DEFAULT_CONFIG, ...loaded }
+        this.applyConfig()
+      }
+    }
+    catch (error) {
+      console.error('[LoggerManager] Failed to load config:', error)
+    }
+  }
+
+  /**
+   * Save configuration to storage
+   */
+  async saveConfig(): Promise<void> {
+    if (!this.configSaver)
+      return
+
+    try {
+      await this.configSaver(this.config)
+    }
+    catch (error) {
+      console.error('[LoggerManager] Failed to save config:', error)
+    }
+  }
+
+  /**
+   * Apply current configuration to all loggers
+   */
+  private applyConfig(): void {
+    for (const [module, logger] of this.loggers) {
+      const moduleConfig = this.config.modules[module]
+      const defaults = MODULE_DEFAULTS[module]
+
+      // Determine enabled state
+      let enabled = this.config.enabled
+      if (moduleConfig?.enabled !== undefined) {
+        enabled = enabled && moduleConfig.enabled
+      }
+      else if (defaults?.enabled !== undefined) {
+        enabled = enabled && defaults.enabled
+      }
+
+      // Determine log level
+      let level = stringToLogLevel(this.config.globalLevel)
+      if (moduleConfig?.level) {
+        level = Math.max(level, stringToLogLevel(moduleConfig.level))
+      }
+      else if (defaults?.level !== undefined) {
+        level = Math.max(level, defaults.level)
+      }
+
+      logger.setEnabled(enabled)
+      logger.setLevel(level)
+    }
+  }
+
+  /**
+   * Reset to default configuration
+   */
+  reset(): void {
+    this.config = { ...DEFAULT_CONFIG }
+    this.applyConfig()
+  }
+}
+
+/**
+ * Singleton instance
+ */
+export const loggerManager = LoggerManager.getInstance()
+
+/**
+ * Shorthand for getting a logger
+ */
+export function getLogger(module: string, options?: Partial<ModuleLoggerOptions>): ModuleLogger {
+  return loggerManager.getLogger(module, options)
+}

package/common/logger/module-logger.ts

@@ -0,0 +1,270 @@
+/**
+ * ModuleLogger
+ *
+ * Provides structured, configurable logging for individual modules.
+ * Supports log levels, timing, grouping, and zero-overhead when disabled.
+ */
+
+import type { ModuleLoggerOptions } from './types'
+import { LogLevel } from './types'
+
+/**
+ * ANSI color codes for terminal output
+ */
+const COLORS: Record<string, string> = {
+  reset: '\x1B[0m',
+  gray: '\x1B[90m',
+  red: '\x1B[31m',
+  green: '\x1B[32m',
+  yellow: '\x1B[33m',
+  blue: '\x1B[34m',
+  magenta: '\x1B[35m',
+  cyan: '\x1B[36m',
+  white: '\x1B[37m',
+  bgRed: '\x1B[41m',
+  bgGreen: '\x1B[42m',
+  bgYellow: '\x1B[43m',
+  bgBlue: '\x1B[44m',
+  bgMagenta: '\x1B[45m',
+  bgCyan: '\x1B[46m',
+  bold: '\x1B[1m',
+}
+
+/**
+ * Level color mapping
+ */
+const LEVEL_COLORS: Record<LogLevel, string> = {
+  [LogLevel.DEBUG]: 'gray',
+  [LogLevel.INFO]: 'blue',
+  [LogLevel.WARN]: 'yellow',
+  [LogLevel.ERROR]: 'red',
+  [LogLevel.NONE]: 'white',
+}
+
+/**
+ * Level labels
+ */
+const LEVEL_LABELS: Record<LogLevel, string> = {
+  [LogLevel.DEBUG]: 'DEBUG',
+  [LogLevel.INFO]: 'INFO ',
+  [LogLevel.WARN]: 'WARN ',
+  [LogLevel.ERROR]: 'ERROR',
+  [LogLevel.NONE]: 'NONE ',
+}
+
+/**
+ * ModuleLogger class
+ *
+ * Provides logging capabilities with:
+ * - Log levels (debug, info, warn, error)
+ * - Enable/disable per module
+ * - Timing functions
+ * - Grouping support
+ * - Zero overhead when disabled
+ */
+export class ModuleLogger {
+  private readonly module: string
+  private readonly color: string
+  private readonly prefix: string
+  private enabled: boolean
+  private level: LogLevel
+  private timers: Map<string, number> = new Map()
+  private groupDepth = 0
+
+  constructor(options: ModuleLoggerOptions) {
+    this.module = options.module
+    this.color = options.color ?? 'cyan'
+    this.prefix = options.prefix ?? ''
+    this.enabled = options.enabled ?? true
+    this.level = options.level ?? LogLevel.DEBUG
+  }
+
+  /**
+   * Check if logger is enabled
+   */
+  isEnabled(): boolean {
+    return this.enabled
+  }
+
+  /**
+   * Get current log level
+   */
+  getLevel(): LogLevel {
+    return this.level
+  }
+
+  /**
+   * Get module name
+   */
+  getModule(): string {
+    return this.module
+  }
+
+  /**
+   * Get color
+   */
+  getColor(): string {
+    return this.color
+  }
+
+  /**
+   * Set enabled state
+   */
+  setEnabled(enabled: boolean): void {
+    this.enabled = enabled
+  }
+
+  /**
+   * Set log level
+   */
+  setLevel(level: LogLevel): void {
+    this.level = level
+  }
+
+  /**
+   * Log debug message
+   */
+  debug(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.DEBUG, message, ...args)
+  }
+
+  /**
+   * Log info message
+   */
+  info(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.INFO, message, ...args)
+  }
+
+  /**
+   * Log warning message
+   */
+  warn(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.WARN, message, ...args)
+  }
+
+  /**
+   * Log error message
+   */
+  error(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.ERROR, message, ...args)
+  }
+
+  /**
+   * Start a timer
+   */
+  time(label: string): void {
+    if (!this.shouldLog(LogLevel.DEBUG))
+      return
+    this.timers.set(label, performance.now())
+  }
+
+  /**
+   * End a timer and log duration
+   */
+  timeEnd(label: string): number {
+    if (!this.shouldLog(LogLevel.DEBUG))
+      return 0
+    const start = this.timers.get(label)
+    if (start === undefined) {
+      this.warn(`Timer "${label}" does not exist`)
+      return 0
+    }
+    this.timers.delete(label)
+    const duration = performance.now() - start
+    this.debug(`${label}: ${duration.toFixed(2)}ms`)
+    return duration
+  }
+
+  /**
+   * Start a log group
+   */
+  group(label: string): void {
+    if (!this.shouldLog(LogLevel.DEBUG))
+      return
+    this.info(label)
+    this.groupDepth++
+  }
+
+  /**
+   * End a log group
+   */
+  groupEnd(): void {
+    if (this.groupDepth > 0) {
+      this.groupDepth--
+    }
+  }
+
+  /**
+   * Create a child logger with a sub-module prefix
+   */
+  child(subModule: string): ModuleLogger {
+    return new ModuleLogger({
+      module: `${this.module}:${subModule}`,
+      color: this.color,
+      enabled: this.enabled,
+      level: this.level,
+      prefix: this.prefix,
+    })
+  }
+
+  /**
+   * Check if a level should be logged
+   */
+  private shouldLog(level: LogLevel): boolean {
+    return this.enabled && level >= this.level
+  }
+
+  /**
+   * Core logging method
+   */
+  private log(level: LogLevel, message: string, ...args: unknown[]): void {
+    if (!this.shouldLog(level))
+      return
+
+    const timestamp = this.formatTimestamp()
+    const levelLabel = LEVEL_LABELS[level]
+    const levelColor = COLORS[LEVEL_COLORS[level]] ?? ''
+    const moduleColor = COLORS[this.color] ?? ''
+    const reset = COLORS.reset
+
+    // Build indent for groups
+    const indent = '  '.repeat(this.groupDepth)
+
+    // Format: [HH:MM:SS.mmm] [module] LEVEL message
+    const formattedModule = `${moduleColor}[${this.module}]${reset}`
+    const formattedLevel = `${levelColor}${levelLabel}${reset}`
+    const formattedMessage = `${indent}${message}`
+
+    const output = `${COLORS.gray}[${timestamp}]${reset} ${formattedModule} ${formattedLevel} ${formattedMessage}`
+
+    // Use appropriate console method
+    switch (level) {
+      case LogLevel.DEBUG:
+        console.debug(output, ...args)
+        break
+      case LogLevel.INFO:
+        console.info(output, ...args)
+        break
+      case LogLevel.WARN:
+        console.warn(output, ...args)
+        break
+      case LogLevel.ERROR:
+        console.error(output, ...args)
+        break
+      default:
+        console.log(output, ...args)
+    }
+  }
+
+  /**
+   * Format timestamp as HH:MM:SS.mmm
+   */
+  private formatTimestamp(): string {
+    const now = new Date()
+    const hours = now.getHours().toString().padStart(2, '0')
+    const minutes = now.getMinutes().toString().padStart(2, '0')
+    const seconds = now.getSeconds().toString().padStart(2, '0')
+    const ms = now.getMilliseconds().toString().padStart(3, '0')
+    return `${hours}:${minutes}:${seconds}.${ms}`
+  }
+}