standard-log 11.5.1 → 11.5.2

package/ts/console.ts

@@ -5,66 +5,75 @@ import { polyfill } from './platform.js'
 import type { ConsoleLike, LogEntry, LogFormatter, LogReporter, LogReporterOptions } from './types.js'
 
 export function toConsoleMethod(level: number) {
-  switch (true) {
-    // edge case in case none is somehow written
-    case (level <= 0): return 'debug'
-    case (level <= logLevels.error): return 'error'
-    case (level <= logLevels.warn): return 'warn'
-    case (level <= logLevels.info): return 'info'
-    default: return 'debug'
-  }
+	switch (true) {
+		// edge case in case none is somehow written
+		case level <= 0:
+			return 'debug'
+		case level <= logLevels.error:
+			return 'error'
+		case level <= logLevels.warn:
+			return 'warn'
+		case level <= logLevels.info:
+			return 'info'
+		default:
+			return 'debug'
+	}
 }
 
 // istanbul ignore next
 /* eslint-disable no-console */
 function buildPolyfillConsole() {
-  // old phantomjs does not have bind function
-  const hasBind = !!console.log.bind as boolean
-  if (hasBind) {
-    return {
-      // the `typeof` guards against IE where `console.log.apply()`
-      // results in error `Object doesn't support property or method 'apply'`
-      debug: (typeof console.info === 'function' ? console.debug : console.log).bind(console),
-      info: (typeof console.info === 'function' ? console.info : console.log).bind(console),
-      warn: (typeof console.warn === 'function' ? console.warn : console.log).bind(console),
-      error: (typeof console.error === 'function' ? console.error : console.log).bind(console)
-    }
-  }
-  else {
-    return {
-      debug: buildFn(typeof console.debug === 'function' ? 'debug' : 'log'),
-      info: buildFn(typeof console.info === 'function' ? 'info' : 'log'),
-      warn: buildFn(typeof console.warn === 'function' ? 'warn' : 'log'),
-      error: buildFn(typeof console.error === 'function' ? 'error' : 'log'),
-    }
-  }
+	// old phantomjs does not have bind function
+	const hasBind = !!console.log.bind as boolean
+	if (hasBind) {
+		return {
+			// the `typeof` guards against IE where `console.log.apply()`
+			// results in error `Object doesn't support property or method 'apply'`
+			debug: (typeof console.info === 'function' ? console.debug : console.log).bind(console),
+			info: (typeof console.info === 'function' ? console.info : console.log).bind(console),
+			warn: (typeof console.warn === 'function' ? console.warn : console.log).bind(console),
+			error: (typeof console.error === 'function' ? console.error : console.log).bind(console)
+		}
+	} else {
+		return {
+			debug: buildFn(typeof console.debug === 'function' ? 'debug' : 'log'),
+			info: buildFn(typeof console.info === 'function' ? 'info' : 'log'),
+			warn: buildFn(typeof console.warn === 'function' ? 'warn' : 'log'),
+			error: buildFn(typeof console.error === 'function' ? 'error' : 'log')
+		}
+	}
 }
 
 // istanbul ignore next
 function buildFn(name: 'debug' | 'info' | 'warn' | 'error' | 'log') {
-  return function (...args: any[]) { console[name](...args) }
+	return function (...args: any[]) {
+		console[name](...args)
+	}
 }
 
-
 export type ConsoleLogFormatter = LogFormatter<any[]>
 export type ConsoleLogReporter = LogReporter<any[]> & { console: ConsoleLike }
 export type ConsoleLogReporterOptions = LogReporterOptions<any[]>
 
 export function createConsoleLogReporter(options?: ConsoleLogReporterOptions): ConsoleLogReporter {
-  const { id, formatter, filter } = unpartial({ id: 'console', formatter: consoleFormatter }, options)
-  if (!polyfill.console) polyfill.console = buildPolyfillConsole()
+	const { id, formatter, filter } = unpartial({ id: 'console', formatter: consoleFormatter }, options)
+	if (!polyfill.console) polyfill.console = buildPolyfillConsole()
 
-  return Object.freeze({
-    id,
-    isConsoleReporter: true,
-    get formatter() { return formatter },
-    get filter() { return filter },
-    console: polyfill.console,
-    write(entry: LogEntry) {
-      if (filter && !filter(entry)) return
-      const values = formatter(entry)
-      const method = toConsoleMethod(entry.level)
-      this.console[method](...values)
-    }
-  })
+	return Object.freeze({
+		id,
+		isConsoleReporter: true,
+		get formatter() {
+			return formatter
+		},
+		get filter() {
+			return filter
+		},
+		console: polyfill.console,
+		write(entry: LogEntry) {
+			if (filter && !filter(entry)) return
+			const values = formatter(entry)
+			const method = toConsoleMethod(entry.level)
+			this.console[method](...values)
+		}
+	})
 }

package/ts/errors.ts

@@ -4,16 +4,16 @@ import { IsoError, ModuleError } from 'iso-error'
  * @deprecated No longer used since 11.2.0
  */
 export class StandardLogError extends ModuleError {
-  constructor(description: string, options?: IsoError.Options) {
-    super('standard-log', description, options)
-  }
+	constructor(description: string, options?: IsoError.Options) {
+		super('standard-log', description, options)
+	}
 }
 
 /**
  * @deprecated no longer used since 11.2.0
  */
 export class InvalidId extends StandardLogError {
-  constructor(public id: string, options?: IsoError.Options) {
-    super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options)
-  }
+	constructor(public id: string, options?: IsoError.Options) {
+		super(`logger id only supports alphanumeric, unicode characters, and [:_-.]. Received ${id}`, options)
+	}
 }

package/ts/formatter.ts

@@ -6,25 +6,25 @@ import type { LogEntry } from './types.js'
 export type TimestampFormat = 'none' | 'iso' | 'elapsed'
 
 export function createTimestampFormatter(format: TimestampFormat): (timestamp: Date) => string | undefined {
-  switch (format) {
-    case 'none':
-      return (_timestamp: Date) => undefined
-    case 'iso':
-      return (timestamp: Date) => timestamp.toISOString()
-    case 'elapsed': {
-      let lastTick: number
-      return (timestamp: Date) => {
-        const newTick = timestamp.getTime()
-        const result = ms(lastTick === undefined ? 0 : newTick - lastTick)
-        lastTick = newTick
-        return result
-      }
-    }
-  }
+	switch (format) {
+		case 'none':
+			return (_timestamp: Date) => undefined
+		case 'iso':
+			return (timestamp: Date) => timestamp.toISOString()
+		case 'elapsed': {
+			let lastTick: number
+			return (timestamp: Date) => {
+				const newTick = timestamp.getTime()
+				const result = ms(lastTick === undefined ? 0 : newTick - lastTick)
+				lastTick = newTick
+				return result
+			}
+		}
+	}
 }
 
 export function formatLogLevel(level: number) {
-  return `(${upperCase(toLogLevelName(level))})`
+	return `(${upperCase(toLogLevelName(level))})`
 }
 
 /**
@@ -34,12 +34,12 @@ export function formatLogLevel(level: number) {
  * This is typically useful for writing logs to file
  */
 export function plainLogFormatter({ id, level, args, timestamp }: LogEntry) {
-  return [timestamp.toISOString(), id, formatLogLevel(level), ...args]
+	return [timestamp.toISOString(), id, formatLogLevel(level), ...args]
 }
 
 /**
  * Formats log entry like default console log.
  */
 export function consoleFormatter({ args }: LogEntry) {
-  return args
+	return args
 }

package/ts/index.ts

@@ -4,13 +4,28 @@ export * from './formatter.js'
 export * from './logLevels.js'
 export * from './memory.js'
 export {
-  configGlobal, createStandardLog, createStandardLogForTest,
-  getLogger, suppressLogs
+	configGlobal,
+	createStandardLog,
+	createStandardLogForTest,
+	getLogger,
+	suppressLogs
 } from './standardLog.js'
 export type { GetLogger, StandardLog, StandardLogForTest } from './standardLog.js'
 export type {
-  ConsoleLike, LogEntry, LogFilter, LogFormatter, LogFunction, Logger, LoggerOptions, LogLevel,
-  LogLevelEntry, LogMethod, LogMethodNames, LogReporter, LogReporterOptions, ReporterFilter,
-  StandardLogInstance, StandardLogOptions
+	ConsoleLike,
+	LogEntry,
+	LogFilter,
+	LogFormatter,
+	LogFunction,
+	Logger,
+	LoggerOptions,
+	LogLevel,
+	LogLevelEntry,
+	LogMethod,
+	LogMethodNames,
+	LogReporter,
+	LogReporterOptions,
+	ReporterFilter,
+	StandardLogInstance,
+	StandardLogOptions
 } from './types.js'
-

package/ts/logLevels.ts

@@ -1,108 +1,107 @@
-
 export const logLevels = {
-  /**
-   * none: 0
-   */
-  none: 0 as const,
-  /**
-   * emergency: 100
-   *
-   * emergency -> alert
-   */
-  emergency: 100 as const,
-  /**
-   * alert: 200
-   *
-   * emergency -> alert -> critical
-   */
-  alert: 200 as const,
-  /**
-   * critical: 300
-   *
-   * alert -> critical -> error
-   */
-  critical: 300 as const,
-  /**
-   * error: 400
-   *
-   * critical -> error -> warn
-   */
-  error: 400 as const,
-  /**
-   * warn: 500
-   *
-   * error -> warn -> notice
-   */
-  warn: 500 as const,
-  /**
-   * notice: 600
-   *
-   * warn -> notice -> info
-   */
-  notice: 600 as const,
-  /**
-   * info: 700
-   *
-   * notice -> info -> debug
-   */
-  info: 700 as const,
-  /**
-   * debug: 800
-   *
-   * info -> debug -> trace
-   */
-  debug: 800 as const,
-  /**
-   * trace: 900
-   *
-   * debug -> trace -> planck
-   */
-  trace: 900 as const,
-  /**
-   * planck: Infinity
-   * `planck unit` is a very small unit <https://en.wikipedia.org/wiki/Planck_units>.
-   *
-   * trace -> planck
-   */
-  planck: Infinity,
-  /**
-   * all: Infinity
-   */
-  all: Infinity
+	/**
+	 * none: 0
+	 */
+	none: 0 as const,
+	/**
+	 * emergency: 100
+	 *
+	 * emergency -> alert
+	 */
+	emergency: 100 as const,
+	/**
+	 * alert: 200
+	 *
+	 * emergency -> alert -> critical
+	 */
+	alert: 200 as const,
+	/**
+	 * critical: 300
+	 *
+	 * alert -> critical -> error
+	 */
+	critical: 300 as const,
+	/**
+	 * error: 400
+	 *
+	 * critical -> error -> warn
+	 */
+	error: 400 as const,
+	/**
+	 * warn: 500
+	 *
+	 * error -> warn -> notice
+	 */
+	warn: 500 as const,
+	/**
+	 * notice: 600
+	 *
+	 * warn -> notice -> info
+	 */
+	notice: 600 as const,
+	/**
+	 * info: 700
+	 *
+	 * notice -> info -> debug
+	 */
+	info: 700 as const,
+	/**
+	 * debug: 800
+	 *
+	 * info -> debug -> trace
+	 */
+	debug: 800 as const,
+	/**
+	 * trace: 900
+	 *
+	 * debug -> trace -> planck
+	 */
+	trace: 900 as const,
+	/**
+	 * planck: Infinity
+	 * `planck unit` is a very small unit <https://en.wikipedia.org/wiki/Planck_units>.
+	 *
+	 * trace -> planck
+	 */
+	planck: Infinity,
+	/**
+	 * all: Infinity
+	 */
+	all: Infinity
 }
 
 /**
  * Convert default log level value to log level name.
  */
 export function toLogLevelName(level: number) {
-  if (level <= 100) return 'emergency'
-  if (level <= 200) return 'alert'
-  if (level <= 300) return 'critical'
-  if (level <= 400) return 'error'
-  if (level <= 500) return 'warn'
-  if (level <= 600) return 'notice'
-  if (level <= 700) return 'info'
-  if (level <= 800) return 'debug'
-  if (level <= 900) return 'trace'
-  return 'planck'
+	if (level <= 100) return 'emergency'
+	if (level <= 200) return 'alert'
+	if (level <= 300) return 'critical'
+	if (level <= 400) return 'error'
+	if (level <= 500) return 'warn'
+	if (level <= 600) return 'notice'
+	if (level <= 700) return 'info'
+	if (level <= 800) return 'debug'
+	if (level <= 900) return 'trace'
+	return 'planck'
 }
 
 /**
  * Convert default log level name to log level value.
  */
 export function toLogLevel(name: string): number | undefined {
-  return (logLevels as any)[name.toLocaleLowerCase()]
+	return (logLevels as any)[name.toLocaleLowerCase()]
 }
 
 export const DEFAULT_LOG_METHOD_NAMES: string[] = [
-  'emergency',
-  'alert',
-  'critical',
-  'error',
-  'warn',
-  'notice',
-  'info',
-  'debug',
-  'trace',
-  'planck'
+	'emergency',
+	'alert',
+	'critical',
+	'error',
+	'warn',
+	'notice',
+	'info',
+	'debug',
+	'trace',
+	'planck'
 ]

package/ts/logStore.ts

@@ -1,54 +1,63 @@
-
 import { mapKey, record, reduceByKey, reduceKey } from 'type-plus'
 import { createConsoleLogReporter } from './console.js'
 import { logLevels, toLogLevel, toLogLevelName } from './logLevels.js'
 import type { Logger, LogLevel, LogMethodNames, LogReporter, StandardLogOptions } from './types.js'
 
-export function createLogStore<N extends string = LogMethodNames>(options: Required<StandardLogOptions<N>>): LogStore {
-  return {
-    loggers: record(),
-    nonConsoleLoggers: record(),
-    reporters: options.reporters || [createConsoleLogReporter()],
-    logLevel: options.logLevel,
-    logLevelStore: logLevelStore(options)
-  }
+export function createLogStore<N extends string = LogMethodNames>(
+	options: Required<StandardLogOptions<N>>
+): LogStore {
+	return {
+		loggers: record(),
+		nonConsoleLoggers: record(),
+		reporters: options.reporters || [createConsoleLogReporter()],
+		logLevel: options.logLevel,
+		logLevelStore: logLevelStore(options)
+	}
 }
 
 export interface LogStore {
-  loggers: Record<string, Logger>,
-  nonConsoleLoggers: Record<string, Logger>,
-  reporters: LogReporter[],
-  logLevel: LogLevel,
-  logLevelStore: ReturnType<typeof logLevelStore>
+	loggers: Record<string, Logger>
+	nonConsoleLoggers: Record<string, Logger>
+	reporters: LogReporter[]
+	logLevel: LogLevel
+	logLevelStore: ReturnType<typeof logLevelStore>
 }
 
 export interface LogLevelStoreOptions {
-  customLevels?: Record<string, number>
+	customLevels?: Record<string, number>
 }
 
 export function logLevelStore(options: LogLevelStoreOptions) {
-  const customLevels = options.customLevels || record()
+	const customLevels = options.customLevels || record()
 
-  const store = {
-    customLevels,
-    customLevelsReverse: reduceByKey(customLevels, (p, k) => {
-      p[customLevels[k]] = k
-      return p
-    }, {} as Record<number, string>)
-  }
-  return {
-    getName(level: number) {
-      return store.customLevelsReverse[level] ?? toLogLevelName(level)
-    },
-    getLevel(name: string) {
-      return store.customLevels[name] ?? toLogLevel(name)
-    },
-    getAllLevels() {
-      return reduceKey(logLevels, (result, name) => {
-        if (name !== 'none' && name !== 'all') result.push({ name, level: logLevels[name] })
+	const store = {
+		customLevels,
+		customLevelsReverse: reduceByKey(
+			customLevels,
+			(p, k) => {
+				p[customLevels[k]] = k
+				return p
+			},
+			{} as Record<number, string>
+		)
+	}
+	return {
+		getName(level: number) {
+			return store.customLevelsReverse[level] ?? toLogLevelName(level)
+		},
+		getLevel(name: string) {
+			return store.customLevels[name] ?? toLogLevel(name)
+		},
+		getAllLevels() {
+			return reduceKey(
+				logLevels,
+				(result, name) => {
+					if (name !== 'none' && name !== 'all') result.push({ name, level: logLevels[name] })
 
-        return result
-      }, mapKey(store.customLevels, name => ({ name, level: store.customLevels[name] })))
-    }
-  }
+					return result
+				},
+				mapKey(store.customLevels, name => ({ name, level: store.customLevels[name] }))
+			)
+		}
+	}
 }