@innei/pretty-logger-core 0.3.0

package/consola/reporters/fancy.ts

@@ -0,0 +1,152 @@
+import _stringWidth from 'string-width'
+import type { LogLevel, LogType } from '../constants'
+import type { FormatOptions, LogObject } from '../types'
+import type { BoxOpts } from '../utils/box'
+
+import { stripAnsi } from '../utils'
+import { box } from '../utils/box'
+import { colors } from '../utils/color'
+import { parseStack } from '../utils/error'
+import { isUnicodeSupported } from '../utils/tester'
+import { BasicReporter } from './basic'
+
+export const TYPE_COLOR_MAP: { [k in LogType]?: string } = {
+  info: 'cyan',
+  fail: 'red',
+  success: 'green',
+  ready: 'green',
+  start: 'magenta',
+}
+
+export const LEVEL_COLOR_MAP: { [k in LogLevel]?: string } = {
+  0: 'red',
+  1: 'yellow',
+}
+
+const unicode = isUnicodeSupported()
+const s = (c: string, fallback: string) => (unicode ? c : fallback)
+const TYPE_ICONS: { [k in LogType]?: string } = {
+  error: s('✖', '×'),
+  fatal: s('✖', '×'),
+  ready: s('✔', '√'),
+  warn: s('⚠', '‼'),
+  info: s('ℹ', 'i'),
+  success: s('✔', '√'),
+  debug: s('⚙', 'D'),
+  trace: s('→', '→'),
+  fail: s('✖', '×'),
+  start: s('◐', 'o'),
+  log: '',
+}
+
+function stringWidth(str: string) {
+  // https://github.com/unjs/consola/issues/204
+  if (!(Intl as any).Segmenter) {
+    return stripAnsi(str).length
+  }
+  return _stringWidth(str)
+}
+
+export class FancyReporter extends BasicReporter {
+  formatStack(stack: string) {
+    return `\n${parseStack(stack)
+      .map(
+        (line) =>
+          `  ${line
+            .replace(/^at +/, (m) => colors.gray(m))
+            .replace(/\((.+)\)/, (_, m) => `(${colors.cyan(m)})`)}`,
+      )
+      .join('\n')}`
+  }
+
+  formatType(logObj: LogObject, isBadge: boolean, opts: FormatOptions) {
+    const typeColor =
+      (TYPE_COLOR_MAP as any)[logObj.type] ||
+      (LEVEL_COLOR_MAP as any)[logObj.level] ||
+      'gray'
+
+    if (isBadge) {
+      return getBgColor(typeColor)(
+        colors.black(` ${logObj.type.toUpperCase()} `),
+      )
+    }
+
+    const _type =
+      typeof (TYPE_ICONS as any)[logObj.type] === 'string'
+        ? (TYPE_ICONS as any)[logObj.type]
+        : (logObj as any).icon || logObj.type
+
+    return _type ? getColor(typeColor)(_type) : ''
+  }
+
+  formatLogObj(logObj: LogObject, opts: FormatOptions) {
+    const [message, ...additional] = this.formatArgs(logObj.args, opts).split(
+      '\n',
+    )
+
+    if (logObj.type === 'box') {
+      return box(
+        characterFormat(
+          message + (additional.length > 0 ? `\n${additional.join('\n')}` : ''),
+        ),
+        {
+          title: logObj.title
+            ? characterFormat(logObj.title as string)
+            : undefined,
+          style: logObj.style as BoxOpts['style'],
+        },
+      )
+    }
+
+    const date = this.formatDate(logObj.date, opts)
+    const coloredDate = date && colors.gray(date)
+
+    const isBadge = (logObj.badge as boolean) ?? logObj.level < 2
+    const type = this.formatType(logObj, isBadge, opts)
+
+    const tag = logObj.tag ? colors.gray(logObj.tag) : ''
+
+    let line
+    const left = this.filterAndJoin([type, characterFormat(message)])
+    const right = this.filterAndJoin(opts.columns ? [tag, coloredDate] : [tag])
+    const space =
+      (opts.columns || 0) - stringWidth(left) - stringWidth(right) - 2
+
+    line =
+      space > 0 && (opts.columns || 0) >= 80
+        ? left + ' '.repeat(space) + right
+        : (right ? `${colors.gray(`[${right}]`)} ` : '') + left
+
+    line += characterFormat(
+      additional.length > 0 ? `\n${additional.join('\n')}` : '',
+    )
+
+    if (logObj.type === 'trace') {
+      const _err = new Error(`Trace: ${logObj.message}`)
+      line += this.formatStack(_err.stack || '')
+    }
+
+    return isBadge ? `\n${line}\n` : line
+  }
+}
+
+function characterFormat(str: string) {
+  return (
+    str
+      // highlight backticks
+      .replace(/`([^`]+)`/gm, (_, m) => colors.cyan(m))
+      // underline underscores
+      .replace(/\s+_([^_]+)_\s+/gm, (_, m) => ` ${colors.underline(m)} `)
+  )
+}
+
+function getColor(color = 'white') {
+  return (colors as any)[color] || colors.white
+}
+
+function getBgColor(color = 'bgWhite') {
+  return (
+    (colors as any)[`bg${color[0].toUpperCase()}${color.slice(1)}`] ||
+    colors.bgWhite
+  )
+}

package/consola/reporters/file.ts

@@ -0,0 +1,126 @@
+import { createWriteStream } from 'fs'
+import * as fs from 'fs'
+import { dirname } from 'path'
+import { CronJob } from 'cron'
+import type { WriteStream } from 'fs'
+import type { ConsolaOptions, LogObject } from '../types'
+
+import { getLogFilePath } from '../../tool.util'
+import { writeStream } from '../utils/stream'
+import { LoggerReporter } from './logger'
+
+export interface FileReporterConfig {
+  loggerDir: string
+  /**
+   * @default 'stdout_%d%.log'
+   */
+  stdoutFileFormat?: string
+  /**
+   * @default 'error.log'
+   */
+  stderrFileFormat?: string
+
+  /**
+   * refresh logger file stream
+   * @default '0 0 * * *'
+   */
+  cron?: string
+
+  /**
+   * Error log will be written to stdout and stderr
+   * @default false
+   */
+  errWriteToStdout?: boolean
+}
+
+export class FileReporter extends LoggerReporter {
+  constructor(private readonly configs: FileReporterConfig) {
+    super()
+    this.refreshWriteStream()
+
+    this.scheduleRefreshWriteStream()
+  }
+
+  private stdoutStream?: WriteStream
+  private stderrStream?: WriteStream
+
+  private __job?: CronJob
+
+  private scheduleRefreshWriteStream() {
+    const { cron = '0 0 * * *' } = this.configs
+    const job = new CronJob(cron, this.refreshWriteStream.bind(this))
+    job.start()
+
+    this.__job = job
+  }
+
+  teardown() {
+    this.__job?.stop()
+    this.stdoutStream?.end()
+    this.stderrStream?.end()
+  }
+
+  private refreshWriteStream() {
+    const {
+      loggerDir,
+      stderrFileFormat = 'error.log',
+      stdoutFileFormat = 'stdout_%d.log',
+    } = this.configs
+
+    const stdoutPath = getLogFilePath(loggerDir, stdoutFileFormat)
+    const stderrPath = getLogFilePath(loggerDir, stderrFileFormat)
+
+    createLoggerFileIfNotExist(stdoutPath)
+    createLoggerFileIfNotExist(stderrPath)
+
+    const options = {
+      encoding: 'utf-8',
+      flags: 'a+',
+    } as const
+
+    ;[this.stderrStream, this.stdoutStream].forEach((stream) => {
+      stream?.end()
+    })
+
+    this.stdoutStream = createWriteStream(stdoutPath, options)
+    this.stderrStream = createWriteStream(stderrPath, options)
+    ;[this.stderrStream, this.stdoutStream].forEach((stream) => {
+      writeStream(
+        '\n========================================================\n',
+        stream,
+      )
+    })
+  }
+
+  log(logObj: LogObject, ctx: { options: ConsolaOptions }) {
+    if (!this.stdoutStream || !this.stderrStream) {
+      return
+    }
+    const finalStdout = this.stdoutStream
+    const finalStderr = this.stderrStream || this.stdoutStream
+    const line = super.formatLogObj(logObj, {
+      ...ctx.options.formatOptions,
+      columns: undefined,
+    })
+
+    if (this.configs.errWriteToStdout && logObj.level < 2) {
+      writeStream(`${line}\n`, finalStdout)
+    }
+    return writeStream(
+      `${line}\n`,
+      logObj.level < 2 ? finalStderr : finalStdout,
+    )
+  }
+}
+
+const createLoggerFileIfNotExist = (path: string) => {
+  const dirPath = dirname(path)
+
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true })
+  }
+
+  if (!fs.existsSync(path)) {
+    fs.writeFileSync(path, '', { flag: 'wx' })
+  }
+}

package/consola/reporters/index.ts

@@ -0,0 +1,6 @@
+export * from './basic'
+export * from './browser'
+export * from './fancy'
+export * from './file'
+export * from './logger'
+export * from './subscriber'

package/consola/reporters/logger.ts

@@ -0,0 +1,31 @@
+/* eslint-disable prefer-rest-params */
+import picocolors from 'picocolors'
+import { isDevelopment } from 'std-env'
+import type { FormatOptions, LogObject } from '../types'
+
+import { getShortTime } from '../../tool.util'
+import { FancyReporter } from './fancy'
+
+export class LoggerReporter extends FancyReporter {
+  private latestLogTime: number = Date.now()
+  public formatDate(date: Date, opts: FormatOptions): string {
+    const isInVirtualTerminal = typeof opts.columns === 'undefined'
+    if (isDevelopment) {
+      const now = Date.now()
+      const delta = now - this.latestLogTime
+      this.latestLogTime = now
+      return `+${delta | 0}ms ${super.formatDate(date, opts)}`
+    }
+
+    return isInVirtualTerminal ? '' : super.formatDate(date, opts)
+  }
+
+  public formatLogObj(logObj: LogObject, opts: FormatOptions): string {
+    const isInVirtualTerminal = typeof opts.columns === 'undefined'
+    return isInVirtualTerminal
+      ? `${picocolors.gray(getShortTime(new Date()))} ${super
+          .formatLogObj(logObj, opts)
+          .replace(/^\n/, '')}`.trimEnd()
+      : super.formatLogObj(logObj, opts)
+  }
+}

package/consola/reporters/subscriber.ts

@@ -0,0 +1,30 @@
+import EventEmitter from 'events'
+import type { ConsolaInstance } from '../consola'
+import type { ConsolaOptions, LogObject, WrappedConsola } from '../types'
+
+import { LoggerReporter } from './logger'
+
+export const wrapperSubscribers = (
+  consola: ConsolaInstance,
+): WrappedConsola => {
+  Object.assign(consola, {
+    onData: (handler: (data: string) => any) =>
+      SubscriberReporter.subscriber.on('log', handler),
+    onStdOut: (handler: (data: string) => any) =>
+      SubscriberReporter.subscriber.on('stdout', handler),
+    onStdErr: (handler: (data: string) => any) =>
+      SubscriberReporter.subscriber.on('stderr', handler),
+  })
+  // @ts-expect-error
+  return consola
+}
+
+export class SubscriberReporter extends LoggerReporter {
+  static subscriber = new EventEmitter()
+  log(logObj: LogObject, ctx: { options: ConsolaOptions }) {
+    const line = super.formatLogObj(logObj, ctx)
+    const event = logObj.level < 2 ? 'stderr' : 'stdout'
+    SubscriberReporter.subscriber.emit(event, line)
+    SubscriberReporter.subscriber.emit('log', line)
+  }
+}

package/consola/shared.ts

@@ -0,0 +1,6 @@
+export { LogLevels, LogTypes } from './constants'
+export { Consola } from './consola'
+
+export type * from './types'
+export type { ConsolaInstance } from './consola'
+export type { LogLevel, LogType } from './constants'

package/consola/types.ts

@@ -0,0 +1,60 @@
+import type { ConsolaInstance } from './consola'
+import type { LogLevel, LogType } from './constants'
+
+export interface ConsolaOptions {
+  reporters: ConsolaReporter[]
+  types: Record<LogType, InputLogObject>
+  level: LogLevel
+  defaults: InputLogObject
+  throttle: number
+  throttleMin: number
+  stdout?: NodeJS.WriteStream
+  stderr?: NodeJS.WriteStream
+  mockFn?: (type: LogType, defaults: InputLogObject) => (...args: any) => void
+  formatOptions: FormatOptions
+}
+
+/**
+ * @see https://nodejs.org/api/util.html#util_util_inspect_object_showhidden_depth_colors
+ */
+export interface FormatOptions {
+  columns?: number
+  date?: boolean
+  colors?: boolean
+  compact?: boolean | number
+  [key: string]: unknown
+}
+
+export interface InputLogObject {
+  level?: LogLevel
+  tag?: string
+  type?: LogType
+  message?: string
+  additional?: string | string[]
+  args?: any[]
+  date?: Date
+}
+
+export interface LogObject extends InputLogObject {
+  level: LogLevel
+  type: LogType
+  tag: string
+  args: any[]
+  date: Date
+  [key: string]: unknown
+}
+
+export interface ConsolaReporter {
+  log: (
+    logObj: LogObject,
+    ctx: {
+      options: ConsolaOptions
+    },
+  ) => void
+}
+
+export interface WrappedConsola extends ConsolaInstance {
+  onData: (handler: (data: string) => any) => WrappedConsola
+  onStdOut: (handler: (data: string) => any) => WrappedConsola
+  onStdErr: (handler: (data: string) => any) => WrappedConsola
+}