@innei/pretty-logger-core 0.3.0

package/consola/consola.ts

@@ -0,0 +1,409 @@
+import { defu } from 'defu'
+import type { LogLevel, LogType } from './constants'
+import type {
+  ConsolaOptions,
+  ConsolaReporter,
+  InputLogObject,
+  LogObject,
+} from './types'
+
+import { LogTypes } from './constants'
+import { isLogObj } from './utils/log'
+
+let paused = false
+const queue: any[] = []
+
+export class Consola {
+  options: ConsolaOptions
+
+  _lastLog: {
+    serialized?: string
+    object?: LogObject
+    count?: number
+    time?: Date
+    timeout?: ReturnType<typeof setTimeout>
+  }
+
+  _mockFn?: ConsolaOptions['mockFn']
+
+  constructor(options: Partial<ConsolaOptions> = {}) {
+    // Options
+    const types = options.types || LogTypes
+    this.options = defu(
+      <ConsolaOptions>{
+        ...options,
+        defaults: { ...options.defaults },
+        level: _normalizeLogLevel(options.level, types),
+        reporters: [...(options.reporters || [])],
+      },
+      <Partial<ConsolaOptions>>{
+        types: LogTypes,
+        throttle: 1000,
+        throttleMin: 5,
+        formatOptions: {
+          date: true,
+          colors: false,
+          compact: true,
+        },
+      },
+    )
+
+    // Create logger functions for current instance
+    for (const type in types) {
+      const defaults: InputLogObject = {
+        type: type as LogType,
+        ...this.options.defaults,
+        ...types[type as LogType],
+      }
+      // @ts-expect-error
+      ;(this as unknown as ConsolaInstance)[type as LogType] =
+        this._wrapLogFn(defaults)
+      // @ts-ignore
+      ;(this as unknown as ConsolaInstance)[type].raw = this._wrapLogFn(
+        defaults,
+        true,
+      )
+    }
+
+    // Use _mockFn if is set
+    if (this.options.mockFn) {
+      this.mockTypes()
+    }
+
+    // Track of last log
+    this._lastLog = {}
+  }
+
+  get level() {
+    return this.options.level
+  }
+
+  set level(level) {
+    this.options.level = _normalizeLogLevel(
+      level,
+      this.options.types,
+      this.options.level,
+    )
+  }
+
+  create(options: Partial<ConsolaOptions>): ConsolaInstance {
+    const instance = new Consola({
+      ...this.options,
+      ...options,
+    }) as ConsolaInstance
+
+    if (this._mockFn) {
+      instance.mockTypes(this._mockFn)
+    }
+
+    return instance
+  }
+
+  withDefaults(defaults: InputLogObject): ConsolaInstance {
+    return this.create({
+      ...this.options,
+      defaults: {
+        ...this.options.defaults,
+        ...defaults,
+      },
+    })
+  }
+
+  withTag(tag: string): ConsolaInstance {
+    return this.withDefaults({
+      tag: this.options.defaults.tag
+        ? `${this.options.defaults.tag}:${tag}`
+        : tag,
+    })
+  }
+
+  addReporter(reporter: ConsolaReporter) {
+    this.options.reporters.push(reporter)
+    return this
+  }
+
+  removeReporter(reporter: ConsolaReporter) {
+    if (reporter) {
+      const i = this.options.reporters.indexOf(reporter)
+      if (i >= 0) {
+        return this.options.reporters.splice(i, 1)
+      }
+    } else {
+      this.options.reporters.splice(0)
+    }
+    return this
+  }
+
+  setReporters(reporters: ConsolaReporter[]) {
+    this.options.reporters = Array.isArray(reporters) ? reporters : [reporters]
+    return this
+  }
+
+  wrapAll() {
+    this.wrapConsole()
+    this.wrapStd()
+  }
+
+  restoreAll() {
+    this.restoreConsole()
+    this.restoreStd()
+  }
+
+  wrapConsole() {
+    for (const type in this.options.types) {
+      // Backup original value
+      if (!(console as any)[`__${type}`]) {
+        // eslint-disable-line no-console
+        ;(console as any)[`__${type}`] = (console as any)[type] // eslint-disable-line no-console
+      }
+      // Override
+      ;(console as any)[type] = (this as unknown as ConsolaInstance)[
+        type as LogType
+      ].raw // eslint-disable-line no-console
+    }
+  }
+
+  restoreConsole() {
+    for (const type in this.options.types) {
+      // Restore if backup is available
+      if ((console as any)[`__${type}`]) {
+        // eslint-disable-line no-console
+        ;(console as any)[type] = (console as any)[`__${type}`] // eslint-disable-line no-console
+        delete (console as any)[`__${type}`] // eslint-disable-line no-console
+      }
+    }
+  }
+
+  wrapStd() {
+    this._wrapStream(this.options.stdout, 'log')
+    this._wrapStream(this.options.stderr, 'log')
+  }
+
+  _wrapStream(stream: NodeJS.WriteStream | undefined, type: LogType) {
+    if (!stream) {
+      return
+    }
+
+    // Backup original value
+    if (!(stream as any).__write) {
+      ;(stream as any).__write = stream.write
+    }
+
+    // Override
+    ;(stream as any).write = (data: any) => {
+      ;(this as unknown as ConsolaInstance)[type].raw(String(data).trim())
+    }
+  }
+
+  restoreStd() {
+    this._restoreStream(this.options.stdout)
+    this._restoreStream(this.options.stderr)
+  }
+
+  _restoreStream(stream?: NodeJS.WriteStream) {
+    if (!stream) {
+      return
+    }
+
+    if ((stream as any).__write) {
+      stream.write = (stream as any).__write
+      delete (stream as any).__write
+    }
+  }
+
+  pauseLogs() {
+    paused = true
+  }
+
+  resumeLogs() {
+    paused = false
+
+    // Process queue
+    const _queue = queue.splice(0)
+    for (const item of _queue) {
+      item[0]._logFn(item[1], item[2])
+    }
+  }
+
+  mockTypes(mockFn?: ConsolaOptions['mockFn']) {
+    const _mockFn = mockFn || this.options.mockFn
+
+    this._mockFn = _mockFn
+
+    if (typeof _mockFn !== 'function') {
+      return
+    }
+
+    for (const type in this.options.types) {
+      // @ts-expect-error
+      ;(this as unknown as ConsolaInstance)[type as LogType] =
+        _mockFn(type as LogType, this.options.types[type as LogType]) ||
+        (this as unknown as ConsolaInstance)[type as LogType]
+      ;(this as unknown as ConsolaInstance)[type as LogType].raw = (
+        this as unknown as ConsolaInstance
+      )[type as LogType]
+    }
+  }
+
+  _wrapLogFn(defaults: InputLogObject, isRaw?: boolean) {
+    return (...args: any[]) => {
+      if (paused) {
+        queue.push([this, defaults, args, isRaw])
+        return
+      }
+      return this._logFn(defaults, args, isRaw)
+    }
+  }
+
+  _logFn(defaults: InputLogObject, args: any[], isRaw?: boolean) {
+    if (((defaults.level as number) || 0) > this.level) {
+      return false
+    }
+
+    // Construct a new log object
+    const logObj: Partial<LogObject> = {
+      date: new Date(),
+      args: [],
+      ...defaults,
+      level: _normalizeLogLevel(defaults.level, this.options.types),
+    }
+
+    // Consume arguments
+    if (!isRaw && args.length === 1 && isLogObj(args[0])) {
+      Object.assign(logObj, args[0])
+    } else {
+      logObj.args = [...args]
+    }
+
+    // Aliases
+    if (logObj.message) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      logObj.args!.unshift(logObj.message)
+      delete logObj.message
+    }
+    if (logObj.additional) {
+      if (!Array.isArray(logObj.additional)) {
+        logObj.additional = logObj.additional.split('\n')
+      }
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      logObj.args!.push(`\n${logObj.additional.join('\n')}`)
+      delete logObj.additional
+    }
+
+    // Normalize type to lowercase
+    logObj.type = (
+      typeof logObj.type === 'string' ? logObj.type.toLowerCase() : 'log'
+    ) as LogType
+    logObj.tag = typeof logObj.tag === 'string' ? logObj.tag : ''
+
+    // Resolve log
+    /**
+     * @param newLog false if the throttle expired and
+     *  we don't want to log a duplicate
+     */
+    const resolveLog = (newLog = false) => {
+      const repeated = (this._lastLog.count || 0) - this.options.throttleMin
+      if (this._lastLog.object && repeated > 0) {
+        const args = [...this._lastLog.object.args]
+        if (repeated > 1) {
+          args.push(`(repeated ${repeated} times)`)
+        }
+        this._log({ ...this._lastLog.object, args })
+        this._lastLog.count = 1
+      }
+
+      // Log
+      if (newLog) {
+        this._lastLog.object = logObj as LogObject
+        this._log(logObj as LogObject)
+      }
+    }
+
+    // Throttle
+    clearTimeout(this._lastLog.timeout)
+    const diffTime =
+      this._lastLog.time && logObj.date
+        ? logObj.date.getTime() - this._lastLog.time.getTime()
+        : 0
+    this._lastLog.time = logObj.date
+    if (diffTime < this.options.throttle) {
+      try {
+        const serializedLog = JSON.stringify([
+          logObj.type,
+          logObj.tag,
+          logObj.args,
+        ])
+        const isSameLog = this._lastLog.serialized === serializedLog
+        this._lastLog.serialized = serializedLog
+        if (isSameLog) {
+          this._lastLog.count = (this._lastLog.count || 0) + 1
+          if (this._lastLog.count > this.options.throttleMin) {
+            // Auto-resolve when throttle is timed out
+            this._lastLog.timeout = setTimeout(
+              resolveLog,
+              this.options.throttle,
+            )
+            return // SPAM!
+          }
+        }
+      } catch {
+        // Circular References
+      }
+    }
+
+    resolveLog(true)
+  }
+
+  _log(logObj: LogObject) {
+    for (const reporter of this.options.reporters) {
+      reporter.log(logObj, {
+        options: this.options,
+      })
+    }
+  }
+}
+
+function _normalizeLogLevel(
+  input: LogLevel | LogType | undefined,
+  types: any = {},
+  defaultLevel = 3,
+) {
+  if (input === undefined) {
+    return defaultLevel
+  }
+  if (typeof input === 'number') {
+    return input
+  }
+  if (types[input] && types[input].level !== undefined) {
+    return types[input].level
+  }
+  return defaultLevel
+}
+
+export interface LogFn {
+  (message: InputLogObject | any, ...args: any[]): void
+  raw: (...args: any[]) => void
+}
+export type ConsolaInstance = Consola & Record<LogType, LogFn>
+
+// Legacy support
+// @ts-expect-error
+Consola.prototype.add = Consola.prototype.addReporter
+// @ts-expect-error
+Consola.prototype.remove = Consola.prototype.removeReporter
+// @ts-expect-error
+Consola.prototype.clear = Consola.prototype.removeReporter
+// @ts-expect-error
+Consola.prototype.withScope = Consola.prototype.withTag
+// @ts-expect-error
+Consola.prototype.mock = Consola.prototype.mockTypes
+// @ts-expect-error
+Consola.prototype.pause = Consola.prototype.pauseLogs
+// @ts-expect-error
+Consola.prototype.resume = Consola.prototype.resumeLogs
+
+export function createConsola(
+  options: Partial<ConsolaOptions> = {},
+): ConsolaInstance {
+  return new Consola(options) as ConsolaInstance
+}

package/consola/constants.ts

@@ -0,0 +1,109 @@
+import type { LogObject } from './types'
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type LogLevel = 0 | 1 | 2 | 3 | 4 | 5 | (number & {})
+
+export const LogLevels: Record<LogType, number> = {
+  silent: Number.NEGATIVE_INFINITY,
+
+  fatal: 0,
+  error: 0,
+
+  warn: 1,
+
+  log: 2,
+  info: 3,
+
+  success: 3,
+  fail: 3,
+  ready: 3,
+  start: 3,
+  box: 3,
+
+  debug: 4,
+
+  trace: 5,
+
+  verbose: Number.POSITIVE_INFINITY,
+}
+
+export type LogType =
+  // 0
+  | 'silent'
+  | 'fatal'
+  | 'error'
+  // 1
+  | 'warn'
+  // 2
+  | 'log'
+  // 3
+  | 'info'
+  | 'success'
+  | 'fail'
+  | 'ready'
+  | 'start'
+  | 'box'
+  // Verbose
+  | 'debug'
+  | 'trace'
+  | 'verbose'
+
+export const LogTypes: Record<LogType, Partial<LogObject>> = {
+  // Silent
+  silent: {
+    level: -1,
+  },
+
+  // Level 0
+  fatal: {
+    level: LogLevels.fatal,
+  },
+  error: {
+    level: LogLevels.error,
+  },
+
+  // Level 1
+  warn: {
+    level: LogLevels.warn,
+  },
+
+  // Level 2
+  log: {
+    level: LogLevels.log,
+  },
+
+  // Level 3
+  info: {
+    level: LogLevels.info,
+  },
+  success: {
+    level: LogLevels.success,
+  },
+  fail: {
+    level: LogLevels.fail,
+  },
+  ready: {
+    level: LogLevels.info,
+  },
+  start: {
+    level: LogLevels.info,
+  },
+  box: {
+    level: LogLevels.info,
+  },
+
+  // Level 4
+  debug: {
+    level: LogLevels.debug,
+  },
+
+  // Level 5
+  trace: {
+    level: LogLevels.trace,
+  },
+
+  // Verbose
+  verbose: {
+    level: LogLevels.verbose,
+  },
+}

package/consola/core.ts

@@ -0,0 +1,2 @@
+export { createConsola } from './consola'
+export * from './shared'

package/consola/index.ts

@@ -0,0 +1,50 @@
+import { isCI, isDebug, isTest } from 'std-env'
+import type { ConsolaInstance } from './consola'
+import type { LogLevel } from './constants'
+import type { ConsolaOptions } from './types'
+
+import { createConsola as _createConsola } from './consola'
+import { LogLevels } from './constants'
+import { BasicReporter } from './reporters/basic'
+import { FancyReporter } from './reporters/fancy'
+
+export * from './shared'
+
+export function createConsola(
+  options: Partial<ConsolaOptions & { fancy: boolean }> = {},
+): ConsolaInstance {
+  // Log level
+  let level = _getDefaultLogLevel()
+  if (process.env.CONSOLA_LEVEL) {
+    level = Number.parseInt(process.env.CONSOLA_LEVEL) ?? level
+  }
+
+  // Create new consola instance
+  const consola = _createConsola({
+    level: level as LogLevel,
+    defaults: { level },
+    stdout: process.stdout,
+    stderr: process.stderr,
+
+    reporters: options.reporters || [
+      options.fancy ?? !(isCI || isTest)
+        ? new FancyReporter()
+        : new BasicReporter(),
+    ],
+    ...options,
+  })
+
+  return consola
+}
+
+function _getDefaultLogLevel() {
+  if (isDebug) {
+    return LogLevels.debug
+  }
+  if (isTest) {
+    return LogLevels.warn
+  }
+  return LogLevels.info
+}
+
+export const consola = createConsola()

package/consola/reporters/basic.ts

@@ -0,0 +1,74 @@
+import { formatWithOptions } from 'node:util'
+import type {
+  ConsolaOptions,
+  ConsolaReporter,
+  FormatOptions,
+  LogObject,
+} from '../types'
+
+import { parseStack } from '../utils/error'
+import { writeStream } from '../utils/stream'
+
+const bracket = (x: string) => (x ? `[${x}]` : '')
+
+export class BasicReporter implements ConsolaReporter {
+  formatStack(stack: string, opts: FormatOptions) {
+    return `  ${parseStack(stack).join('\n  ')}`
+  }
+
+  formatArgs(args: any[], opts: FormatOptions) {
+    const _args = args.map((arg) => {
+      if (arg && typeof arg.stack === 'string') {
+        return `${arg.message}\n${this.formatStack(arg.stack, opts)}`
+      }
+      return arg
+    })
+
+    // Only supported with Node >= 10
+    // https://nodejs.org/api/util.html#util_util_inspect_object_options
+    return formatWithOptions(opts, ..._args)
+  }
+
+  formatDate(date: Date, opts: FormatOptions) {
+    return opts.date ? date.toLocaleTimeString() : ''
+  }
+
+  filterAndJoin(arr: any[]) {
+    return arr.filter(Boolean).join(' ')
+  }
+
+  formatLogObj(logObj: LogObject, opts: FormatOptions) {
+    const message = this.formatArgs(logObj.args, opts)
+
+    if (logObj.type === 'box') {
+      return `\n${[
+        bracket(logObj.tag),
+        logObj.title && logObj.title,
+        ...message.split('\n'),
+      ]
+        .filter(Boolean)
+        .map((l) => ` > ${l}`)
+        .join('\n')}\n`
+    }
+
+    return this.filterAndJoin([
+      bracket(logObj.type),
+      bracket(logObj.tag),
+      message,
+    ])
+  }
+
+  log(logObj: LogObject, ctx: { options: ConsolaOptions }) {
+    const line = this.formatLogObj(logObj, {
+      columns: (ctx.options.stdout as any).columns || 0,
+      ...ctx.options.formatOptions,
+    })
+
+    return writeStream(
+      `${line}\n`,
+      logObj.level < 2
+        ? ctx.options.stderr || process.stderr
+        : ctx.options.stdout || process.stdout,
+    )
+  }
+}

package/consola/reporters/browser.ts

@@ -0,0 +1,70 @@
+import type { LogObject } from '../types'
+
+export class BrowserReporter {
+  options: any
+  defaultColor: string
+  levelColorMap: Record<number, string>
+  typeColorMap: Record<string, string>
+
+  constructor(options: any) {
+    this.options = { ...options }
+
+    this.defaultColor = '#7f8c8d' // Gray
+    this.levelColorMap = {
+      0: '#c0392b', // Red
+      1: '#f39c12', // Yellow
+      3: '#00BCD4', // Cyan
+    }
+    this.typeColorMap = {
+      success: '#2ecc71', // Green
+    }
+  }
+
+  _getLogFn(level: number) {
+    if (level < 1) {
+      return (console as any).__error || console.error
+    }
+    if (level === 1) {
+      return (console as any).__warn || console.warn
+    }
+    return (console as any).__log || console.log
+  }
+
+  log(logObj: LogObject) {
+    const consoleLogFn = this._getLogFn(logObj.level)
+
+    // Type
+    const type = logObj.type === 'log' ? '' : logObj.type
+
+    // Tag
+    const tag = logObj.tag || ''
+
+    // Styles
+    const color =
+      this.typeColorMap[logObj.type] ||
+      this.levelColorMap[logObj.level] ||
+      this.defaultColor
+    const style = `
+      background: ${color};
+      border-radius: 0.5em;
+      color: white;
+      font-weight: bold;
+      padding: 2px 0.5em;
+    `
+
+    const badge = `%c${[tag, type].filter(Boolean).join(':')}`
+
+    // Log to the console
+    if (typeof logObj.args[0] === 'string') {
+      consoleLogFn(
+        `${badge}%c ${logObj.args[0]}`,
+        style,
+        // Empty string as style resets to default console style
+        '',
+        ...logObj.args.slice(1),
+      )
+    } else {
+      consoleLogFn(badge, style, ...logObj.args)
+    }
+  }
+}