@innei/pretty-logger-core 0.3.0

package/consola/utils/box.ts

@@ -0,0 +1,320 @@
+import { getColor } from './color'
+import { stripAnsi } from './string'
+
+export type BoxBorderStyle = {
+  /**
+   * Top left corner
+   * @example `┌`
+   * @example `╔`
+   * @example `╓`
+   */
+  tl: string
+  /**
+   * Top right corner
+   * @example `┐`
+   * @example `╗`
+   * @example `╖`
+   */
+  tr: string
+  /**
+   * Bottom left corner
+   * @example `└`
+   * @example `╚`
+   * @example `╙`
+   */
+  bl: string
+  /**
+   * Bottom right corner
+   * @example `┘`
+   * @example `╝`
+   * @example `╜`
+   */
+  br: string
+  /**
+   * Horizontal line
+   * @example `─`
+   * @example `═`
+   * @example `─`
+   */
+  h: string
+  /**
+   * Vertical line
+   * @example `│`
+   * @example `║`
+   * @example `║`
+   */
+  v: string
+}
+
+const boxStylePresets: Record<string, BoxBorderStyle> = {
+  solid: {
+    tl: '┌',
+    tr: '┐',
+    bl: '└',
+    br: '┘',
+    h: '─',
+    v: '│',
+  },
+  double: {
+    tl: '╔',
+    tr: '╗',
+    bl: '╚',
+    br: '╝',
+    h: '═',
+    v: '║',
+  },
+  doubleSingle: {
+    tl: '╓',
+    tr: '╖',
+    bl: '╙',
+    br: '╜',
+    h: '─',
+    v: '║',
+  },
+  doubleSingleRounded: {
+    tl: '╭',
+    tr: '╮',
+    bl: '╰',
+    br: '╯',
+    h: '─',
+    v: '║',
+  },
+  singleThick: {
+    tl: '┏',
+    tr: '┓',
+    bl: '┗',
+    br: '┛',
+    h: '━',
+    v: '┃',
+  },
+  singleDouble: {
+    tl: '╒',
+    tr: '╕',
+    bl: '╘',
+    br: '╛',
+    h: '═',
+    v: '│',
+  },
+  singleDoubleRounded: {
+    tl: '╭',
+    tr: '╮',
+    bl: '╰',
+    br: '╯',
+    h: '═',
+    v: '│',
+  },
+  rounded: {
+    tl: '╭',
+    tr: '╮',
+    bl: '╰',
+    br: '╯',
+    h: '─',
+    v: '│',
+  },
+}
+
+export type BoxStyle = {
+  /**
+   * The border color
+   * @default 'white'
+   */
+  borderColor:
+    | 'black'
+    | 'red'
+    | 'green'
+    | 'yellow'
+    | 'blue'
+    | 'magenta'
+    | 'cyan'
+    | 'white'
+    | 'gray'
+    | 'blackBright'
+    | 'redBright'
+    | 'greenBright'
+    | 'yellowBright'
+    | 'blueBright'
+    | 'magentaBright'
+    | 'cyanBright'
+    | 'whiteBright'
+
+  /**
+   * The border style
+   * @default 'solid'
+   * @example 'single-double-rounded'
+   * @example
+   * ```ts
+   * {
+   *   tl: '┌',
+   *   tr: '┐',
+   *   bl: '└',
+   *   br: '┘',
+   *   h: '─',
+   *   v: '│',
+   * }
+   * ```
+   */
+  borderStyle: BoxBorderStyle | keyof typeof boxStylePresets
+
+  /**
+   * The vertical alignment of the text
+   * @default 'center'
+   */
+  valign: 'top' | 'center' | 'bottom'
+
+  /**
+   * The padding of the box
+   * @default 2
+   */
+  padding: number
+
+  /**
+   * The left margin of the box
+   * @default 1
+   */
+  marginLeft: number
+
+  /**
+   * The top margin of the box
+   * @default 1
+   */
+  marginTop: number
+
+  /**
+   * The top margin of the box
+   * @default 1
+   */
+  marginBottom: number
+}
+
+/**
+ * The border options of the box
+ */
+export type BoxOpts = {
+  /**
+   * Title that will be displayed on top of the box
+   * @example 'Hello World'
+   * @example 'Hello {name}'
+   */
+  title?: string
+
+  style?: Partial<BoxStyle>
+}
+
+const defaultStyle: BoxStyle = {
+  borderColor: 'white',
+  borderStyle: 'rounded',
+  valign: 'center',
+  padding: 2,
+  marginLeft: 1,
+  marginTop: 1,
+  marginBottom: 1,
+}
+
+export function box(text: string, _opts: BoxOpts = {}) {
+  const opts = {
+    ..._opts,
+    style: {
+      ...defaultStyle,
+      ..._opts.style,
+    },
+  }
+
+  // Split the text into lines
+  const textLines = text.split('\n')
+
+  // Create the box
+  const boxLines = []
+
+  // Get the characters for the box and colorize
+  const _color = getColor(opts.style.borderColor)
+  const borderStyle = {
+    ...(typeof opts.style.borderStyle === 'string'
+      ? boxStylePresets[
+          opts.style.borderStyle as keyof typeof boxStylePresets
+        ] || boxStylePresets.solid
+      : opts.style.borderStyle),
+  }
+  if (_color) {
+    for (const key in borderStyle) {
+      borderStyle[key as keyof typeof borderStyle] = _color(
+        borderStyle[key as keyof typeof borderStyle],
+      )
+    }
+  }
+
+  // Calculate the width and height of the box
+  const paddingOffset =
+    opts.style.padding % 2 === 0 ? opts.style.padding : opts.style.padding + 1
+  const height = textLines.length + paddingOffset
+  const width =
+    Math.max(...textLines.map((line) => line.length)) + paddingOffset
+  const widthOffset = width + paddingOffset
+
+  const leftSpace =
+    opts.style.marginLeft > 0 ? ' '.repeat(opts.style.marginLeft) : ''
+
+  // Top line
+  if (opts.style.marginTop > 0) {
+    boxLines.push(''.repeat(opts.style.marginTop))
+  }
+  // Include the title if it exists with borders
+  if (opts.title) {
+    const left = borderStyle.h.repeat(
+      Math.floor((width - stripAnsi(opts.title).length) / 2),
+    )
+    const right = borderStyle.h.repeat(
+      width -
+        stripAnsi(opts.title).length -
+        stripAnsi(left).length +
+        paddingOffset,
+    )
+    boxLines.push(
+      `${leftSpace}${borderStyle.tl}${left}${opts.title}${right}${borderStyle.tr}`,
+    )
+  } else {
+    boxLines.push(
+      `${leftSpace}${borderStyle.tl}${borderStyle.h.repeat(widthOffset)}${
+        borderStyle.tr
+      }`,
+    )
+  }
+
+  // Middle lines
+  const valignOffset =
+    opts.style.valign === 'center'
+      ? Math.floor((height - textLines.length) / 2)
+      : opts.style.valign === 'top'
+      ? height - textLines.length - paddingOffset
+      : height - textLines.length
+
+  for (let i = 0; i < height; i++) {
+    if (i < valignOffset || i >= valignOffset + textLines.length) {
+      // Empty line
+      boxLines.push(
+        `${leftSpace}${borderStyle.v}${' '.repeat(widthOffset)}${
+          borderStyle.v
+        }`,
+      )
+    } else {
+      // Text line
+      const line = textLines[i - valignOffset]
+      const left = ' '.repeat(paddingOffset)
+      const right = ' '.repeat(width - stripAnsi(line).length)
+      boxLines.push(
+        `${leftSpace}${borderStyle.v}${left}${line}${right}${borderStyle.v}`,
+      )
+    }
+  }
+
+  // Bottom line
+  boxLines.push(
+    `${leftSpace}${borderStyle.bl}${borderStyle.h.repeat(widthOffset)}${
+      borderStyle.br
+    }`,
+  )
+  if (opts.style.marginBottom > 0) {
+    boxLines.push(''.repeat(opts.style.marginBottom))
+  }
+
+  return boxLines.join('\n')
+}

package/consola/utils/color.ts

@@ -0,0 +1,132 @@
+/**
+ * Based on https://github.com/jorgebucaran/colorette
+ * Read LICENSE file for more information
+ * https://github.com/jorgebucaran/colorette/blob/20fc196d07d0f87c61e0256eadd7831c79b24108/index.js
+ */
+
+import * as tty from 'node:tty'
+
+// TODO: Migrate to std-env
+const {
+  env = {},
+  argv = [],
+  platform = '',
+} = typeof process === 'undefined' ? {} : process
+const isDisabled = 'NO_COLOR' in env || argv.includes('--no-color')
+const isForced = 'FORCE_COLOR' in env || argv.includes('--color')
+const isWindows = platform === 'win32'
+const isDumbTerminal = env.TERM === 'dumb'
+const isCompatibleTerminal =
+  tty && tty.isatty && tty.isatty(1) && env.TERM && !isDumbTerminal
+const isCI =
+  'CI' in env &&
+  ('GITHUB_ACTIONS' in env || 'GITLAB_CI' in env || 'CIRCLECI' in env)
+const isColorSupported =
+  !isDisabled &&
+  (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI)
+
+function replaceClose(
+  index: number,
+  string: string,
+  close: string,
+  replace: string,
+  head = string.slice(0, Math.max(0, index)) + replace,
+  tail = string.slice(Math.max(0, index + close.length)),
+  next = tail.indexOf(close),
+): string {
+  return head + (next < 0 ? tail : replaceClose(next, tail, close, replace))
+}
+
+function clearBleed(
+  index: number,
+  string: string,
+  open: string,
+  close: string,
+  replace: string,
+) {
+  return index < 0
+    ? open + string + close
+    : open + replaceClose(index, string, close, replace) + close
+}
+
+function filterEmpty(
+  open: string,
+  close: string,
+  replace = open,
+  at = open.length + 1,
+) {
+  return (string: string) =>
+    string || !(string === '' || string === undefined)
+      ? clearBleed(`${string}`.indexOf(close, at), string, open, close, replace)
+      : ''
+}
+
+function init(open: number, close: number, replace?: string) {
+  return filterEmpty(`\u001B[${open}m`, `\u001B[${close}m`, replace)
+}
+
+const colorDefs = {
+  reset: init(0, 0),
+  bold: init(1, 22, '\u001B[22m\u001B[1m'),
+  dim: init(2, 22, '\u001B[22m\u001B[2m'),
+  italic: init(3, 23),
+  underline: init(4, 24),
+  inverse: init(7, 27),
+  hidden: init(8, 28),
+  strikethrough: init(9, 29),
+  black: init(30, 39),
+  red: init(31, 39),
+  green: init(32, 39),
+  yellow: init(33, 39),
+  blue: init(34, 39),
+  magenta: init(35, 39),
+  cyan: init(36, 39),
+  white: init(37, 39),
+  gray: init(90, 39),
+  bgBlack: init(40, 49),
+  bgRed: init(41, 49),
+  bgGreen: init(42, 49),
+  bgYellow: init(43, 49),
+  bgBlue: init(44, 49),
+  bgMagenta: init(45, 49),
+  bgCyan: init(46, 49),
+  bgWhite: init(47, 49),
+  blackBright: init(90, 39),
+  redBright: init(91, 39),
+  greenBright: init(92, 39),
+  yellowBright: init(93, 39),
+  blueBright: init(94, 39),
+  magentaBright: init(95, 39),
+  cyanBright: init(96, 39),
+  whiteBright: init(97, 39),
+  bgBlackBright: init(100, 49),
+  bgRedBright: init(101, 49),
+  bgGreenBright: init(102, 49),
+  bgYellowBright: init(103, 49),
+  bgBlueBright: init(104, 49),
+  bgMagentaBright: init(105, 49),
+  bgCyanBright: init(106, 49),
+  bgWhiteBright: init(107, 49),
+}
+
+export type ColorName = keyof typeof colorDefs
+export type ColorFunction = (text: string | number) => string
+
+function createColors(useColor = isColorSupported) {
+  return useColor
+    ? colorDefs
+    : Object.fromEntries(Object.keys(colorDefs).map((key) => [key, String]))
+}
+
+export const colors = createColors() as Record<ColorName, ColorFunction>
+
+export function getColor(
+  color: ColorName,
+  fallback: ColorName = 'reset',
+): ColorFunction {
+  return colors[color] || colors[fallback]
+}
+
+export function colorize(color: ColorName, text: string | number): string {
+  return getColor(color)(text)
+}

package/consola/utils/error.ts

@@ -0,0 +1,12 @@
+import { sep } from 'node:path'
+
+export function parseStack(stack: string) {
+  const cwd = process.cwd() + sep
+
+  const lines = stack
+    .split('\n')
+    .splice(1)
+    .map((l) => l.trim().replace('file://', '').replace(cwd, ''))
+
+  return lines
+}

package/consola/utils/log.ts

@@ -0,0 +1,22 @@
+export function isPlainObject(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object Object]'
+}
+
+export function isLogObj(arg: any) {
+  // Should be plain object
+  if (!isPlainObject(arg)) {
+    return false
+  }
+
+  // Should contains either 'message' or 'args' field
+  if (!arg.message && !arg.args) {
+    return false
+  }
+
+  // Handle non-standard error objects
+  if (arg.stack) {
+    return false
+  }
+
+  return true
+}

package/consola/utils/stream.ts

@@ -0,0 +1,9 @@
+import type { WriteStream } from 'node:fs'
+
+export function writeStream(
+  data: any,
+  stream: NodeJS.WriteStream | WriteStream,
+) {
+  const write = (stream as any).__write || stream.write
+  return write.call(stream, data)
+}

package/consola/utils/string.ts

@@ -0,0 +1,64 @@
+const ansiRegex = [
+  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
+].join('|')
+
+export function stripAnsi(text: string) {
+  return text.replace(new RegExp(ansiRegex, 'g'), '')
+}
+
+export function centerAlign(str: string, len: number, space = ' ') {
+  const free = len - str.length
+  if (free <= 0) {
+    return str
+  }
+  const freeLeft = Math.floor(free / 2)
+  let _str = ''
+  for (let i = 0; i < len; i++) {
+    _str +=
+      i < freeLeft || i >= freeLeft + str.length ? space : str[i - freeLeft]
+  }
+  return _str
+}
+
+export function rightAlign(str: string, len: number, space = ' ') {
+  const free = len - str.length
+  if (free <= 0) {
+    return str
+  }
+  let _str = ''
+  for (let i = 0; i < len; i++) {
+    _str += i < free ? space : str[i - free]
+  }
+  return _str
+}
+
+export function leftAlign(str: string, len: number, space = ' ') {
+  let _str = ''
+  for (let i = 0; i < len; i++) {
+    _str += i < str.length ? str[i] : space
+  }
+  return _str
+}
+
+export function align(
+  alignment: 'left' | 'right' | 'center',
+  str: string,
+  len: number,
+  space = ' ',
+) {
+  switch (alignment) {
+    case 'left': {
+      return leftAlign(str, len, space)
+    }
+    case 'right': {
+      return rightAlign(str, len, space)
+    }
+    case 'center': {
+      return centerAlign(str, len, space)
+    }
+    default: {
+      return str
+    }
+  }
+}

package/consola/utils/tester.ts

@@ -0,0 +1,16 @@
+export function isUnicodeSupported() {
+  if (process.platform !== 'win32') {
+    return process.env.TERM !== 'linux' // Linux console (kernel)
+  }
+
+  return (
+    Boolean(process.env.WT_SESSION) || // Windows Terminal
+    Boolean(process.env.TERMINUS_SUBLIME) || // Terminus (<0.2.27)
+    process.env.ConEmuTask === '{cmd::Cmder}' || // ConEmu and cmder
+    process.env.TERM_PROGRAM === 'Terminus-Sublime' ||
+    process.env.TERM_PROGRAM === 'vscode' ||
+    process.env.TERM === 'xterm-256color' ||
+    process.env.TERM === 'alacritty' ||
+    process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm'
+  )
+}

package/consola/utils.ts

@@ -0,0 +1,9 @@
+export * from './utils/box'
+export * from './utils/color'
+export {
+  stripAnsi,
+  centerAlign,
+  rightAlign,
+  leftAlign,
+  align,
+} from './utils/string'

package/consola.instance.ts

@@ -0,0 +1,36 @@
+import { isDevelopment } from 'std-env'
+import type { ConsolaOptions, ConsolaReporter } from './consola'
+import type { FileReporterConfig } from './consola/reporters/file'
+
+import { createConsola, LogLevels } from './consola'
+import { FancyReporter } from './consola/reporters/fancy'
+import { FileReporter } from './consola/reporters/file'
+import {
+  SubscriberReporter,
+  wrapperSubscribers,
+} from './consola/reporters/subscriber'
+
+export interface LoggerConsolaOptions extends Partial<ConsolaOptions> {
+  writeToFile?: FileReporterConfig
+}
+
+export const createLoggerConsola = (options?: LoggerConsolaOptions) => {
+  const reporters: ConsolaReporter[] = [
+    new FancyReporter(),
+    new SubscriberReporter(),
+  ]
+  if (options?.writeToFile) {
+    reporters.push(new FileReporter(options.writeToFile))
+  }
+  const consola = createConsola({
+    formatOptions: {
+      date: true,
+    },
+
+    reporters,
+    level: isDevelopment ? LogLevels.trace : LogLevels.info,
+    ...options,
+  })
+
+  return wrapperSubscribers(consola)
+}