standard-log 11.5.0 → 11.5.2

package/ts/logger.ts

@@ -4,71 +4,81 @@ import type { LogEntry, LogFunction, Logger, LoggerOptions, LogMethodNames, LogR
 import { LogLevel } from './types.js'
 
 export function createLogger<N extends string = LogMethodNames>(
-  store: LogStore, id: string, options?: LoggerOptions
+	store: LogStore,
+	id: string,
+	options?: LoggerOptions
 ): Logger<N | LogMethodNames> {
-  id = sanitizeId(id)
-  const writeTo = options?.writeTo ?? (() => true)
-  const [filter, reporters]: [(reporterId: string) => boolean, LogReporter[]] = typeof writeTo === 'string'
-    ? [id => id === writeTo, store.reporters]
-    : writeTo instanceof RegExp
-      ? [id => writeTo.test(id), store.reporters]
-      : typeof writeTo === 'function'
-        ? [writeTo, store.reporters]
-        : [() => true, [writeTo]]
+	id = sanitizeId(id)
+	const writeTo = options?.writeTo ?? (() => true)
+	const [filter, reporters]: [(reporterId: string) => boolean, LogReporter[]] =
+		typeof writeTo === 'string'
+			? [id => id === writeTo, store.reporters]
+			: writeTo instanceof RegExp
+			? [id => writeTo.test(id), store.reporters]
+			: typeof writeTo === 'function'
+			? [writeTo, store.reporters]
+			: [() => true, [writeTo]]
 
-  function write(entry: LogEntry) {
-    writeToReporters(reporters, entry, filter)
-  }
+	function write(entry: LogEntry) {
+		writeToReporters(reporters, entry, filter)
+	}
 
-  const logger = {
-    level: options?.level,
-    write
-  } as any
+	const logger = {
+		level: options?.level,
+		write
+	} as any
 
-  Object.defineProperties(logger, {
-    id: { value: id, writable: false },
-    count: {
-      writable: false,
-      value: ((counter) => (...args: any[]) => {
-        if (shouldLog(store, logLevels.debug, logger.level))
-          write({
-            id,
-            level: logLevels.debug,
-            args: [++counter, ...args],
-            timestamp: new Date()
-          })
-      })(0)
-    },
-    on: {
-      writable: false,
-      value: (level: number | N | LogMethodNames, logFn: LogFunction) => {
-        const logLevel = typeof level === 'string' ? store.logLevelStore.getLevel(level)! : level
-        if (shouldLog(store, logLevel, logger.level)) {
-          const methodName = store.logLevelStore.getName(logLevel)
-          const bindedMethod = logger[methodName].bind(logger)
-          const result = logFn(bindedMethod, logger.level ?? store.logLevel)
-          if (result) bindedMethod(result)
-        }
-      }
-    }
-  })
-  store.logLevelStore.getAllLevels().forEach(function addMethod({ name, level }) {
-    Object.defineProperty(logger, name, {
-      writable: false,
-      value: (...args: any[]) => {
-        if (shouldLog(store, level, logger.level)) write({ id, level, args, timestamp: new Date() })
-      }
-    })
-  })
-  return logger
+	Object.defineProperties(logger, {
+		id: { value: id, writable: false },
+		count: {
+			writable: false,
+			value: (
+				counter =>
+				(...args: any[]) => {
+					if (shouldLog(store, logLevels.debug, logger.level))
+						write({
+							id,
+							level: logLevels.debug,
+							args: [++counter, ...args],
+							timestamp: new Date()
+						})
+				}
+			)(0)
+		},
+		on: {
+			writable: false,
+			value: (level: number | N | LogMethodNames, logFn: LogFunction) => {
+				const logLevel = typeof level === 'string' ? store.logLevelStore.getLevel(level)! : level
+				if (shouldLog(store, logLevel, logger.level)) {
+					const methodName = store.logLevelStore.getName(logLevel)
+					const bindedMethod = logger[methodName].bind(logger)
+					const result = logFn(bindedMethod, logger.level ?? store.logLevel)
+					if (result) bindedMethod(result)
+				}
+			}
+		}
+	})
+	store.logLevelStore.getAllLevels().forEach(function addMethod({ name, level }) {
+		Object.defineProperty(logger, name, {
+			writable: false,
+			value: (...args: any[]) => {
+				if (shouldLog(store, level, logger.level)) write({ id, level, args, timestamp: new Date() })
+			}
+		})
+	})
+	return logger
 }
 
 function sanitizeId(id: string) {
-  return id.replace(/[`~!#$%^&*()=+[\]{},|<>?]/g, '-')
+	return id.replace(/[`~!#$%^&*()=+[\]{},|<>?]/g, '-')
 }
 
-function writeToReporters(reporters: LogReporter[], logEntry: LogEntry, filter: (reporterId: string) => boolean) {
-  reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
+function writeToReporters(
+	reporters: LogReporter[],
+	logEntry: LogEntry,
+	filter: (reporterId: string) => boolean
+) {
+	reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
 }
 
 /**
@@ -77,5 +87,5 @@ function writeToReporters(reporters: LogReporter[], logEntry: LogEntry, filter:
  * It can be undefined which the global log level will be used.
  */
 function shouldLog(store: LogStore, targetLevel: LogLevel, loggerLevel: LogLevel | undefined) {
-  return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.logLevel)
+	return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.logLevel)
 }

package/ts/memory.ts

@@ -5,71 +5,83 @@ import type { LogEntry, LogFormatter, LogReporter, LogReporterOptions } from './
 import { createConsoleLogReporter } from './console.js'
 
 export type MemoryLogReporter = LogReporter<LogEntry> & {
-  logs: LogEntry[],
-  /**
-   * Gets a simple log message for testing.
-   * The message only contains arguments for each log entry.
-   */
-  getLogMessage(): string,
-  getLogMessages(): string[],
-  getLogMessageWithLevel(): string,
-  getLogMessagesWithIdAndLevel(): string[],
-  emit(): void
+	logs: LogEntry[]
+	/**
+	 * Gets a simple log message for testing.
+	 * The message only contains arguments for each log entry.
+	 */
+	getLogMessage(): string
+	getLogMessages(): string[]
+	getLogMessageWithLevel(): string
+	getLogMessagesWithIdAndLevel(): string[]
+	emit(): void
 }
 
 export type MemoryLogFormatter = LogFormatter<LogEntry>
 
 export function toMessageWithLevel(logs: LogEntry[]) {
-  return logs.map(toInspectLogEntry)
-    .map(log => `${formatLogLevel(log.level)} ${log.args.join(' ')}`)
-    .join('\n')
-    // if it has more than this log,
-    // we assume it is running under tests,
-    // and remove this log to simplify testing.
-    .replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, '')
+	return (
+		logs
+			.map(toInspectLogEntry)
+			.map(log => `${formatLogLevel(log.level)} ${log.args.join(' ')}`)
+			.join('\n')
+			// if it has more than this log,
+			// we assume it is running under tests,
+			// and remove this log to simplify testing.
+			.replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, '')
+	)
 }
 
 export function createMemoryLogReporter(options?: LogReporterOptions<LogEntry>): MemoryLogReporter {
-  return Object.freeze(buildMemoryReporter(unpartial({ id: 'memory' }, options)))
+	return Object.freeze(buildMemoryReporter(unpartial({ id: 'memory' }, options)))
 }
 
 function buildMemoryReporter(options?: LogReporterOptions<LogEntry>) {
-  const { id, formatter, filter } = required({ id: 'memory', formatter: (e: LogEntry) => e }, options)
-  const logs: LogEntry[] = []
-  return {
-    id,
-    get formatter() { return formatter },
-    get filter() { return filter },
-    logs,
-    write(entry: LogEntry) {
-      if (filter && !filter(entry)) return
-      logs.push(formatter(entry))
-    },
-    getLogMessage() {
-      return this.getLogMessages().join('\n')
-    },
-    getLogMessages() {
-      return logs.map(toInspectLogEntry)
-        .map(log => log.args.join(' '))
-    },
-    getLogMessagesWithIdAndLevel() {
-      return logs.map(toInspectLogEntry)
-        .map(log => `${log.id} ${formatLogLevel(log.level)} ${log.args.join(' ')}`)
-    },
-    getLogMessageWithLevel() { return toMessageWithLevel(logs) },
-    /**
-     * emit the saved log to console for easy debugging
-     */
-    emit() {
-      const reporter = createConsoleLogReporter()
-      logs.forEach(l => reporter.write(l))
-    }
-  }
+	const { id, formatter, filter } = required({ id: 'memory', formatter: (e: LogEntry) => e }, options)
+	const logs: LogEntry[] = []
+	return {
+		id,
+		get formatter() {
+			return formatter
+		},
+		get filter() {
+			return filter
+		},
+		logs,
+		write(entry: LogEntry) {
+			if (filter && !filter(entry)) return
+			logs.push(formatter(entry))
+		},
+		getLogMessage() {
+			return this.getLogMessages().join('\n')
+		},
+		getLogMessages() {
+			return logs.map(toInspectLogEntry).map(log => log.args.join(' '))
+		},
+		getLogMessagesWithIdAndLevel() {
+			return logs
+				.map(toInspectLogEntry)
+				.map(log => `${log.id} ${formatLogLevel(log.level)} ${log.args.join(' ')}`)
+		},
+		getLogMessageWithLevel() {
+			return toMessageWithLevel(logs)
+		},
+		/**
+		 * emit the saved log to console for easy debugging
+		 */
+		emit() {
+			const reporter = createConsoleLogReporter()
+			logs.forEach(l => reporter.write(l))
+		}
+	}
 }
 
-export function createMemoryWithConsoleLogReporter(options?: LogReporterOptions<LogEntry>): MemoryLogReporter {
-  return Object.freeze(
-    Object.assign(buildMemoryReporter(unpartial({ id: 'memory-with-console' }, options)), {
-      isConsoleReporter: true
-    }))
+export function createMemoryWithConsoleLogReporter(
+	options?: LogReporterOptions<LogEntry>
+): MemoryLogReporter {
+	return Object.freeze(
+		Object.assign(buildMemoryReporter(unpartial({ id: 'memory-with-console' }, options)), {
+			isConsoleReporter: true
+		})
+	)
 }

package/ts/platform.ts

@@ -3,7 +3,7 @@ import { inspect } from 'util'
 import type { ConsoleLike, LogEntry } from './types.js'
 
 export const toInspectLogEntry = (e: LogEntry) => (
-  e.args = e.args.map(value => typeof value === 'object' && value !== null ? inspect(value) : value),
-  e)
+	(e.args = e.args.map(value => (typeof value === 'object' && value !== null ? inspect(value) : value))), e
+)
 
 export const polyfill: { console?: ConsoleLike } = record()

package/ts/standardLog.ctx.ts

@@ -3,6 +3,6 @@ import type { LogStore } from './logStore.js'
 import type { LogMethodNames, StandardLogInstance } from './types.js'
 
 export const ctx: {
-  configured?: boolean,
-  gsl?: { store: LogStore, standardLog: StandardLogInstance<LogMethodNames> }
+	configured?: boolean
+	gsl?: { store: LogStore; standardLog: StandardLogInstance<LogMethodNames> }
 } = record()

package/ts/standardLog.ts

@@ -4,88 +4,103 @@ import { DEFAULT_LOG_METHOD_NAMES, logLevels } from './logLevels.js'
 import { createLogStore, LogStore } from './logStore.js'
 import { createMemoryLogReporter, MemoryLogReporter } from './memory.js'
 import { ctx } from './standardLog.ctx.js'
-import type { Logger, LoggerOptions, LogLevel, LogMethodNames, StandardLogInstance, StandardLogOptions } from './types.js'
+import type {
+	Logger,
+	LoggerOptions,
+	LogLevel,
+	LogMethodNames,
+	StandardLogInstance,
+	StandardLogOptions
+} from './types.js'
 
-export interface StandardLog<N extends string = LogMethodNames> extends Readonly<StandardLogInstance<N>> {
-}
+export interface StandardLog<N extends string = LogMethodNames> extends Readonly<StandardLogInstance<N>> {}
 
 export function createStandardLog<N extends string = LogMethodNames>(
-  options?: StandardLogOptions<N>
+	options?: StandardLogOptions<N>
 ): StandardLog<N> {
-  const closure = createStandardLogClosure(options)
-  if (options?.reporters?.some(r => !r.id)) {
-    const log = closure.standardLog.getLogger('standard-log')
-    log.critical(`Detected reporter with empty id. This is not allowed as it will create problems with feature like 'getNonConsoleLogger()'. Please add an id to your reporter.`)
-  }
-
-  if (!ctx.gsl) ctx.gsl = closure as any
-  return closure.standardLog
+	const closure = createStandardLogClosure(options)
+	if (options?.reporters?.some(r => !r.id)) {
+		const log = closure.standardLog.getLogger('standard-log')
+		log.critical(
+			`Detected reporter with empty id. This is not allowed as it will create problems with feature like 'getNonConsoleLogger()'. Please add an id to your reporter.`
+		)
+	}
+
+	if (!ctx.gsl) ctx.gsl = closure as any
+	return closure.standardLog
 }
 
-function noop() { }
+function noop() {}
 
 export function createStandardLogClosure<N extends string = LogMethodNames>(
-  options?: StandardLogOptions<N>
-): { store: LogStore, standardLog: StandardLog<N> } {
-  // TODO reporter.id must not be empty
-  const store = createLogStore(required({ logLevel: logLevels.info }, options))
-  const nonConsoleReporters = options?.reporters?.filter(r => !r.isConsoleReporter).map(r => r.id) ?? []
-  const logMethods = DEFAULT_LOG_METHOD_NAMES
-    .concat(Object.keys(options?.customLevels ?? {}))
-    .concat(['on', 'count', 'write'])
-  return {
-    store,
-    standardLog: {
-      get logLevel() { return store.logLevel },
-
-      toLogLevelName(level: number) {
-        return store.logLevelStore.getName(level)
-      },
-      toLogLevel(name: string) {
-        return store.logLevelStore.getLevel(name)
-      },
-      getLogger(id: string, options?: LoggerOptions) {
-        if (store.loggers[id]) return store.loggers[id] as any
-        return store.loggers[id] = createLogger(store, id, { ssf: this.getLogger, ...options }) as any
-      },
-      getNonConsoleLogger(id, options?) {
-        if (store.nonConsoleLoggers[id]) return store.nonConsoleLoggers[id] as any
-
-        if (store.loggers[id]) {
-          const log = this.getLogger('standard-log')
-          log.warn(`attempt to create a non-console logger with existing id ('${id}'), ignoring`)
-          return store.nonConsoleLoggers[id] = createDummyLogger(logMethods)
-        }
-
-        return store.nonConsoleLoggers[id] = nonConsoleReporters.length === 0
-          ? createDummyLogger(logMethods)
-          : createLogger(store, id, {
-            ssf: this.getNonConsoleLogger,
-            ...options,
-            writeTo(reporterId) {
-              return nonConsoleReporters.indexOf(reporterId) >= 0
-            }
-          })
-      },
-    }
-  }
+	options?: StandardLogOptions<N>
+): { store: LogStore; standardLog: StandardLog<N> } {
+	// TODO reporter.id must not be empty
+	const store = createLogStore(required({ logLevel: logLevels.info }, options))
+	const nonConsoleReporters = options?.reporters?.filter(r => !r.isConsoleReporter).map(r => r.id) ?? []
+	const logMethods = DEFAULT_LOG_METHOD_NAMES.concat(Object.keys(options?.customLevels ?? {})).concat([
+		'on',
+		'count',
+		'write'
+	])
+	return {
+		store,
+		standardLog: {
+			get logLevel() {
+				return store.logLevel
+			},
+
+			toLogLevelName(level: number) {
+				return store.logLevelStore.getName(level)
+			},
+			toLogLevel(name: string) {
+				return store.logLevelStore.getLevel(name)
+			},
+			getLogger(id: string, options?: LoggerOptions) {
+				if (store.loggers[id]) return store.loggers[id] as any
+				return (store.loggers[id] = createLogger(store, id, { ssf: this.getLogger, ...options }) as any)
+			},
+			getNonConsoleLogger(id, options?) {
+				if (store.nonConsoleLoggers[id]) return store.nonConsoleLoggers[id] as any
+
+				if (store.loggers[id]) {
+					const log = this.getLogger('standard-log')
+					log.warn(`attempt to create a non-console logger with existing id ('${id}'), ignoring`)
+					return (store.nonConsoleLoggers[id] = createDummyLogger(logMethods))
+				}
+
+				return (store.nonConsoleLoggers[id] =
+					nonConsoleReporters.length === 0
+						? createDummyLogger(logMethods)
+						: createLogger(store, id, {
+								ssf: this.getNonConsoleLogger,
+								...options,
+								writeTo(reporterId) {
+									return nonConsoleReporters.indexOf(reporterId) >= 0
+								}
+						  }))
+			}
+		}
+	}
 }
 
 function createDummyLogger(logMethods: string[]) {
-  return logMethods.reduce((p, m) => {
-    p[m] = noop
-    return p
-  }, record()) as Logger
+	return logMethods.reduce((p, m) => {
+		p[m] = noop
+		return p
+	}, record()) as Logger
 }
 
-export type StandardLogForTest<N extends string = LogMethodNames> = StandardLog<N> & { reporter: MemoryLogReporter }
+export type StandardLogForTest<N extends string = LogMethodNames> = StandardLog<N> & {
+	reporter: MemoryLogReporter
+}
 
 export function createStandardLogForTest<N extends string = LogMethodNames>(
-  logLevel: LogLevel = logLevels.debug
+	logLevel: LogLevel = logLevels.debug
 ): StandardLogForTest<N> {
-  const reporter = createMemoryLogReporter()
-  const closure = createStandardLogClosure<N>({ reporters: [reporter], logLevel })
-  return { ...closure.standardLog, reporter }
+	const reporter = createMemoryLogReporter()
+	const closure = createStandardLogClosure<N>({ reporters: [reporter], logLevel })
+	return { ...closure.standardLog, reporter }
 }
 
 /**
@@ -93,43 +108,47 @@ export function createStandardLogForTest<N extends string = LogMethodNames>(
  */
 export function suppressLogs<R>(block: () => R, log: Logger, ...logs: Logger[]): R
 export function suppressLogs<R>(block: () => R, ...logs: Logger[]): R {
-  const origLevels = logs.map(l => l.level)
-  logs.forEach(l => l.level = logLevels.none)
-  const result = block()
-  logs.forEach((l, i) => l.level = origLevels[i])
-  return result
+	const origLevels = logs.map(l => l.level)
+	logs.forEach(l => (l.level = logLevels.none))
+	const result = block()
+	logs.forEach((l, i) => (l.level = origLevels[i]))
+	return result
 }
 
-export type GetLogger<N extends string = LogMethodNames> = (id: string, options?: LoggerOptions) => Logger<LogMethodNames | N>
+export type GetLogger<N extends string = LogMethodNames> = (
+	id: string,
+	options?: LoggerOptions
+) => Logger<LogMethodNames | N>
 
 export function getLogger<N extends string = LogMethodNames>(id: string, options?: LoggerOptions) {
-  return getGlobalSL<N>().getLogger(id, options)
+	return getGlobalSL<N>().getLogger(id, options)
 }
 
 function getGlobalSL<N extends string = LogMethodNames>(): StandardLogInstance<N> {
-  if (!ctx.gsl) ctx.gsl = createStandardLogClosure()
+	if (!ctx.gsl) ctx.gsl = createStandardLogClosure()
 
-  return ctx.gsl!.standardLog as StandardLogInstance<N>
+	return ctx.gsl!.standardLog as StandardLogInstance<N>
 }
 
 export function configGlobal(options: Omit<StandardLogOptions, 'customLevels'>) {
-  if (ctx.configured) {
-    const log = ctx.gsl!.standardLog.getLogger('standard-log')
-    log.warn('configGlobal() is being called more than once. Please make sure this is expected. Application should use `createStandardLog()` most of the time.')
-  }
-
-  if (ctx.gsl) {
-    if (options.logLevel) {
-      ctx.gsl.store.logLevel = options.logLevel
-    }
-    if (options.reporters) {
-      const reporters = ctx.gsl.store.reporters
-      reporters.length = 0
-      reporters.push(...options.reporters)
-    }
-  }
-  else {
-    ctx.gsl = createStandardLogClosure(options)
-  }
-  ctx.configured = true
+	if (ctx.configured) {
+		const log = ctx.gsl!.standardLog.getLogger('standard-log')
+		log.warn(
+			'configGlobal() is being called more than once. Please make sure this is expected. Application should use `createStandardLog()` most of the time.'
+		)
+	}
+
+	if (ctx.gsl) {
+		if (options.logLevel) {
+			ctx.gsl.store.logLevel = options.logLevel
+		}
+		if (options.reporters) {
+			const reporters = ctx.gsl.store.reporters
+			reporters.length = 0
+			reporters.push(...options.reporters)
+		}
+	} else {
+		ctx.gsl = createStandardLogClosure(options)
+	}
+	ctx.configured = true
 }